gitnexus 1.6.10-rc.99 → 1.6.10

package/dist/core/ingestion/languages/javascript/query.js

@@ -53,18 +53,23 @@ const JS_GRAMMAR = JS;
 function isJsxFile(filePath) {
     return filePath.endsWith('.jsx');
 }
-const JAVASCRIPT_SCOPE_QUERY = `
+export const JAVASCRIPT_SCOPE_QUERY = `
 ;; Scopes — module / class-likes / function-likes
 (program) @scope.module
 
 (class_declaration) @scope.class
 (class) @scope.class
 
-(function_declaration) @scope.function
-(generator_function_declaration) @scope.function
-(function_expression) @scope.function
+;; \`@receiver-owner.this\` — see the matching block in typescript/query.ts
+;; (#2701). Every function form except \`arrow_function\` binds its own \`this\`.
+(function_declaration) @scope.function @receiver-owner.this
+(generator_function_declaration) @scope.function @receiver-owner.this
+(function_expression) @scope.function @receiver-owner.this
+;; \`function*(){}\` as an EXPRESSION. Absent from this list before #2701, so it
+;; was not a scope at all and \`this\` inside one read as the enclosing method's.
+(generator_function) @scope.function @receiver-owner.this
 (arrow_function) @scope.function
-(method_definition) @scope.function
+(method_definition) @scope.function @receiver-owner.this
 
 ;; Object literals get their own scope boundary -- see the matching
 ;; comment in typescript/query.ts (#2545/#2551). Prevents a
@@ -73,6 +78,16 @@ const JAVASCRIPT_SCOPE_QUERY = `
 ;; sibling properties from seeing each other as bare identifiers.
 (object) @scope.object
 
+;; Statement blocks are BINDING scopes (#2699). ECMAScript gives every block its
+;; own environment record, so \`let\`/\`const\`/\`class\`/\`function\` declared in
+;; sibling blocks of one function are DIFFERENT bindings — without this the
+;; resolver sees both as function-level and a call in one branch resolves to
+;; both. \`tsBindingScopeFor\` already implements the other half of the rule:
+;; \`var\` hoists past blocks to the enclosing Function/Module, \`let\`/\`const\`
+;; take the innermost scope, which is now the block.
+(statement_block) @scope.block
+
+
 ;; Declarations — classes
 (class_declaration
   name: (identifier) @declaration.name) @declaration.class
@@ -85,6 +100,15 @@ const JAVASCRIPT_SCOPE_QUERY = `
 (field_definition
   property: (property_identifier) @declaration.name) @declaration.property
 
+;; Object-literal keys of a NAMED object (A1/A5) — the scope-resolution half of
+;; the same rule in TYPESCRIPT/JAVASCRIPT_QUERIES. The parse query mints the
+;; Property NODE; this mints the DEF the resolver can point a read/write at.
+(variable_declarator
+  name: (identifier)
+  value: (object
+    (pair
+      key: (property_identifier) @declaration.name) @declaration.property))
+
 ;; Declarations — free functions
 (function_declaration
   name: (identifier) @declaration.name) @declaration.function
@@ -130,6 +154,67 @@ const JAVASCRIPT_SCOPE_QUERY = `
     name: (identifier) @declaration.name
     value: (function_expression) @declaration.function))
 
+;; CJS property-assignment exports (#2723): \`exports.foo = function () {}\`,
+;; \`module.exports.foo = (a) => a\`. The graph node for these comes from
+;; TYPESCRIPT/JAVASCRIPT_QUERIES; this block is the other half — without a
+;; scope-resolution declaration the node exists but nothing resolves TO it,
+;; so \`impact\` answered "found, zero callers" on a whole CommonJS API.
+;;
+;; The declaration binds the BARE property name into the enclosing (module)
+;; scope, which is what importers see: \`const { foo } = require('./m')\`
+;; matches by name, and a namespace \`m.foo()\` walks the module's defs.
+;;
+;; Same anchor discipline as the blocks above — \`@declaration.function\` sits
+;; on the INNER arrow / function_expression so its range matches the
+;; \`@scope.function\` range.
+;; The three right-hand-side forms share one pattern via an inner LEAF
+;; alternation. tree-sitter 0.21.1 has a known hazard where a top-level
+;; \`[...]\` alternation makes sibling branches share one predicate bucket and
+;; silently drops matches; an inner leaf alternation whose predicates all sit
+;; on captures OUTSIDE it (here \`@_cjs.exports\` / \`@_cjs.module\`, both on the
+;; left-hand side and bound in every branch) is the safe form. Verified by
+;; probing all six receiver × RHS combinations, not by reading.
+;;
+;; \`(generator_function) @scope.function\` is declared near the top of this
+;; query, so the anchor aligns for that branch too.
+(assignment_expression
+  left: (member_expression
+    object: (identifier) @_cjs.receiver
+    property: (property_identifier) @declaration.name)
+  right: [
+    (arrow_function)
+    (function_expression)
+    (generator_function)
+  ] @declaration.function)
+
+;; \`this.X = fn\` at MODULE level of a CommonJS file — there \`this\` IS
+;; \`module.exports\`, so this declares an export. Pruned emit-side for ESM
+;; files (where top-level \`this\` is undefined) and for a \`this\` inside a
+;; function, which is an instance member rather than an export.
+(assignment_expression
+  left: (member_expression
+    object: (this)
+    property: (property_identifier) @declaration.name)
+  right: [
+    (arrow_function)
+    (function_expression)
+    (generator_function)
+  ] @declaration.function)
+
+(assignment_expression
+  left: (member_expression
+    object: (member_expression
+      object: (identifier) @_cjs.module
+      property: (property_identifier) @_cjs.exports)
+    property: (property_identifier) @declaration.name)
+  right: [
+    (arrow_function)
+    (function_expression)
+    (generator_function)
+  ] @declaration.function
+  (#eq? @_cjs.module "module")
+  (#eq? @_cjs.exports "exports"))
+
 ;; Object-property arrows / function expressions named by their pair key.
 ;; Same anchor discipline as the lexical_declaration block above: the
 ;; @declaration.function capture must sit on the INNER arrow/fn-expression.
@@ -347,6 +432,34 @@ const JAVASCRIPT_SCOPE_QUERY = `
   value: (new_expression
     constructor: (member_expression) @type-binding.type)) @type-binding.constructor
 
+;; Class field initializer: \`class C { p = new Outer(); }\` (#2807).
+;; JavaScript has no field annotations at all, so a class field's type can only
+;; ever come from its initializer — without this pattern \`this.p.inner()\` had
+;; nothing to type the receiver with and the receiver fold declined the whole
+;; chain. \`synthesizeConstructorFieldBindings\` in captures.ts already covers the
+;; sibling shape (\`this.p = new Outer()\`), but only inside a \`constructor\`
+;; body, so a field initialized at its declaration matched nothing.
+;;
+;; Anchored on \`field_definition\` so the binding lands in the class body scope,
+;; where \`typeOfMemberOnClass\` reads it — the same anchoring TypeScript uses for
+;; \`public_field_definition\`. Note the JS grammar names the field \`property:\`,
+;; not \`name:\`.
+(field_definition
+  property: (property_identifier) @type-binding.name
+  value: (new_expression
+    constructor: (identifier) @type-binding.type)) @type-binding.constructor
+
+(field_definition
+  property: (property_identifier) @type-binding.name
+  value: (new_expression
+    constructor: (member_expression) @type-binding.type)) @type-binding.constructor
+
+;; Private-name field: \`#p = new Outer()\`.
+(field_definition
+  property: (private_property_identifier) @type-binding.name
+  value: (new_expression
+    constructor: (identifier) @type-binding.type)) @type-binding.constructor
+
 ;; Call-result alias: const u = getUser()
 (variable_declarator
   name: (identifier) @type-binding.name
@@ -478,6 +591,99 @@ const JAVASCRIPT_SCOPE_QUERY = `
 
 (object
   (shorthand_property_identifier) @reference.name @reference.property-key @reference.value-ref)
+
+;; Bare-identifier reads (A2). VALUE POSITIONS ONLY — a blanket
+;; \`(identifier)\` rule would mint a site for every token in the file.
+(arguments
+  (identifier) @reference.name @reference.read.identifier)
+
+(assignment_pattern
+  right: (identifier) @reference.name @reference.read.identifier)
+
+(return_statement
+  (identifier) @reference.name @reference.read.identifier)
+
+;; \`const next = LIMIT\` and \`n > LIMIT\` — both plainly value reads, and both
+;; named in review as gaps between what A2 claimed and what it matched.
+(variable_declarator
+  value: (identifier) @reference.name @reference.read.identifier)
+
+(binary_expression
+  left: (identifier) @reference.name @reference.read.identifier)
+
+(binary_expression
+  right: (identifier) @reference.name @reference.read.identifier)
+
+;; Destructured PARAMETER keys (R2-1c). \`function exit({ exitMinAtrMult = 0 })\`
+;; reads that property off whatever the caller passes, exactly as
+;; \`cfg.exitMinAtrMult\` would — the field just never appears in a
+;; member_expression, so the read had no site at all and the function that
+;; implements the behaviour was missing from "who reads this setting?".
+;;
+;; A distinct anchor rather than @reference.read.member: that tag is filtered
+;; emit-side to matches with a member_expression ancestor (calls and writes
+;; share its shape), and a destructuring pattern has none, so it would be
+;; dropped. The \`read.\` head is what maps this to a read kind, so the new tag
+;; needs no mapping change.
+;;
+;; The object_pattern is the receiver. It is anonymous — there is no name to
+;; type — which is precisely the untyped-receiver case the name-narrowing pass
+;; exists to serve.
+;;
+;; Scoped to formal_parameters deliberately. A destructuring binding elsewhere
+;; (\`const { x } = require('m')\`) is often an import rather than a field read,
+;; and minting a property read for it would attribute module bindings to
+;; unrelated same-named keys.
+(formal_parameters
+  (object_pattern
+    (shorthand_property_identifier_pattern) @reference.name
+      @reference.read.destructured) @reference.receiver)
+
+(formal_parameters
+  (object_pattern
+    (object_assignment_pattern
+      left: (shorthand_property_identifier_pattern) @reference.name
+        @reference.read.destructured)) @reference.receiver)
+
+(formal_parameters
+  (object_pattern
+    (pair_pattern
+      key: (property_identifier) @reference.name
+        @reference.read.destructured)) @reference.receiver)
+
+;; Object-literal keys in RECORD CONSTRUCTION position (R2-1b). Building
+;; \`{ exitContract: { exitMinAtrMult: settings.x } }\` SETS that field, so this
+;; is the write counterpart to the destructured read above — without it
+;; "who reads this setting?" answers well and "who SETS it?" misses the code
+;; that stamps the value.
+;;
+;; A WRITE REFERENCE, deliberately not a definition. The round-1 rule already
+;; mints Property nodes for literals bound to a variable; minting more for
+;; anonymous records would add same-named competitors to the very name-narrowing
+;; that makes these reads resolvable — measured at 26 competing definitions for
+;; one field on the reporting repo. A construction site is a USE of a field, not
+;; another declaration of it.
+;;
+;; Two positions only: nested under a key, and returned. Both are records with a
+;; name attached (the key, or the function). An inline call argument
+;; (\`doThing({ id: 1 })\`) stays excluded for the same reason round 1 excluded
+;; it from definitions — it is call-site data, not a named surface.
+;;
+;; The enclosing literal is the receiver, and it is anonymous, which routes
+;; these through the same narrowing and the same refusal-to-guess as every other
+;; untyped receiver.
+(pair
+  value: (object
+    (pair
+      key: (property_identifier) @reference.name
+        @reference.write.property-key) @_r2b.nested) @reference.receiver)
+
+(return_statement
+  (object
+    (pair
+      key: (property_identifier) @reference.name
+        @reference.write.property-key) @_r2b.returned) @reference.receiver)
+
 `;
 /** JSX-only suffix — appended when compiling against the JSX grammar for .jsx files. */
 const JSX_QUERY_SUFFIX = `

package/dist/core/ingestion/languages/javascript/scope-resolver.js

@@ -39,11 +39,23 @@ import { javascriptProvider } from '../typescript.js';
 import { jsMergeBindings } from './merge-bindings.js';
 import { jsArityCompatibility } from './arity.js';
 import { makeJsResolveImportTarget } from './import-target.js';
+import { loadTsconfigIndex } from '../typescript/tsconfig.js';
+import { loadNodeWorkspacePackages } from '../../import-resolvers/node-workspace-packages.js';
 const javascriptScopeResolver = {
+    // Construction is keyword-prefixed: `new Service(db).doWork()` (#2708).
+    constructionSyntax: { keyword: 'new' },
     language: SupportedLanguages.JavaScript,
     languageProvider: javascriptProvider,
     importEdgeReason: 'javascript-scope: import',
     resolveImportTarget: makeJsResolveImportTarget(),
+    // JavaScript resolution reads the same declared inputs TypeScript does —
+    // `jsconfig.json` is a tsconfig by another name, and `package.json` is shared
+    // outright. Without them a bare specifier used to fall through to suffix
+    // matching (#2953); now it simply does not resolve.
+    loadResolutionConfig: async (repoPath) => ({
+        tsconfigs: await loadTsconfigIndex(repoPath),
+        nodeWorkspacePackages: await loadNodeWorkspacePackages(repoPath),
+    }),
     // JavaScript LEGB — same tier ordering as TypeScript; no declaration-
     // merging across type/value/namespace spaces.
     mergeBindings: (existing, incoming) => [...jsMergeBindings([...existing, ...incoming])],

package/dist/core/ingestion/languages/javascript/simple-hooks.js

@@ -16,7 +16,8 @@
  * prevents language-specific logic from leaking into shared TypeScript
  * infrastructure (DoD.md §2.2).
  */
-import { tsBindingScopeFor, walkToScope } from '../typescript/simple-hooks.js';
+import { walkToScope } from '../../utils/scope-tree-walk.js';
+import { tsBindingScopeFor } from '../typescript/simple-hooks.js';
 export { tsImportOwningScope as jsImportOwningScope, tsReceiverBinding as jsReceiverBinding, } from '../typescript/simple-hooks.js';
 /**
  * Like `tsBindingScopeFor` but additionally hoists

package/dist/core/ingestion/languages/jvm/package-siblings.js

@@ -1,6 +1,17 @@
 import { logger } from '../../../logger.js';
 import { isClassLike } from '../../scope-resolution/scope/walkers.js';
+/** Packages larger than this get no implicit sibling visibility at all — every
+ *  file in them is marked incomplete. `GITNEXUS_MAX_INJECTED_SIBLINGS` bounds
+ *  injection *within* a package and does not lift this skip. */
 const MAX_PACKAGE_FILES = 500;
+const DEFAULT_MAX_INJECTED_SIBLINGS = 200;
+function getMaxInjectedSiblings() {
+    const raw = process.env.GITNEXUS_MAX_INJECTED_SIBLINGS;
+    if (raw === undefined || raw === '')
+        return DEFAULT_MAX_INJECTED_SIBLINGS;
+    const parsed = Number(raw);
+    return Number.isInteger(parsed) && parsed >= 0 ? parsed : DEFAULT_MAX_INJECTED_SIBLINGS;
+}
 export function createJvmPackageSiblingVisibility(options) {
     const incompleteFiles = new Set();
     function populateNamespaceSiblings(parsedFiles, indexes, ctx) {
@@ -40,6 +51,8 @@ export function createJvmPackageSiblingVisibility(options) {
             logger.warn(`[${options.languageLabel}-package-siblings] ${unknownPackageFiles.size} file(s) lacked reliable package facts; wildcard attribution disabled for this language workspace`);
         }
         const augmentations = indexes.bindingAugmentations;
+        const maxInjectedSiblings = getMaxInjectedSiblings();
+        let truncatedFiles = 0;
         for (const bucket of buckets.values()) {
             if (bucket.moduleScopes.length < 2)
                 continue;
@@ -60,25 +73,53 @@ export function createJvmPackageSiblingVisibility(options) {
                         classDefs.push({ def, filePath: parsed.filePath });
                 }
             }
+            // Per-bucket lookups: the per-file loop below is O(files²) over these,
+            // so split each path into segments once here instead of re-splitting it
+            // on every pairwise proximity comparison, and address siblings by path
+            // so a truncated scope can merge its bounded set without rescanning the
+            // whole package.
+            const segmentsByPath = new Map();
+            const moduleScopeByPath = new Map();
+            const parsedByPath = new Map();
+            for (const parsed of bucket.parsed) {
+                segmentsByPath.set(parsed.filePath, pathSegments(parsed.filePath));
+                parsedByPath.set(parsed.filePath, parsed);
+            }
+            for (const sibling of bucket.moduleScopes)
+                moduleScopeByPath.set(sibling.filePath, sibling);
+            const allSiblingPaths = [...parsedByPath.keys()];
             for (const { filePath, scope } of bucket.moduleScopes) {
                 let scopeAug = augmentations.get(scope.id);
                 if (scopeAug === undefined) {
                     scopeAug = new Map();
                     augmentations.set(scope.id, scopeAug);
                 }
+                const ownSegments = segmentsByPath.get(filePath) ?? pathSegments(filePath);
                 const proximityCache = new Map();
                 const candidates = classDefs.filter((candidate) => candidate.filePath !== filePath);
                 for (const candidate of candidates) {
                     if (!proximityCache.has(candidate.filePath)) {
-                        proximityCache.set(candidate.filePath, sharedSegmentCount(candidate.filePath, filePath));
+                        proximityCache.set(candidate.filePath, sharedSegmentCount(segmentsByPath.get(candidate.filePath) ?? [], ownSegments));
                     }
                 }
+                // Nearest-first by shared path prefix. Ties (the common case in a flat
+                // package, where every sibling shares the same directory) keep the
+                // walker's traversal order, so the retained set is deterministic but
+                // arbitrary among equally-near candidates — which is why truncation
+                // marks the file incomplete below rather than being treated as exact.
                 candidates.sort((a, b) => (proximityCache.get(b.filePath) ?? 0) - (proximityCache.get(a.filePath) ?? 0));
                 const injectedIds = new Set();
-                for (const { def } of candidates) {
+                const injectedPaths = new Set();
+                let truncated = false;
+                for (const { def, filePath: defPath } of candidates) {
                     if (injectedIds.has(def.nodeId) || def.qualifiedName === undefined)
                         continue;
+                    if (maxInjectedSiblings > 0 && injectedIds.size >= maxInjectedSiblings) {
+                        truncated = true;
+                        break;
+                    }
                     injectedIds.add(def.nodeId);
+                    injectedPaths.add(defPath);
                     const simpleName = def.qualifiedName.includes('.')
                         ? def.qualifiedName.slice(def.qualifiedName.lastIndexOf('.') + 1)
                         : def.qualifiedName;
@@ -87,17 +128,40 @@ export function createJvmPackageSiblingVisibility(options) {
                         scopeAug.set(simpleName, bindings);
                     bindings.push({ def, origin: 'namespace' });
                 }
+                if (truncated) {
+                    // Sibling visibility for this file is now partial, and downstream
+                    // Spring attribution treats a complete flag as "this package's names
+                    // are fully known". Marking it incomplete keeps wildcard attribution
+                    // conservative instead of silently resolving against a truncated set.
+                    incompleteFiles.add(filePath);
+                    truncatedFiles++;
+                }
+                // Keep the two halves of "what this file can see" in agreement: when
+                // the cap truncated the binding set, merge type bindings from the same
+                // bounded sibling set only — and iterate that set directly, so the cap
+                // bounds the merge work too instead of just filtering a full scan. An
+                // untruncated scope merges every sibling as before, including ones that
+                // contribute no class-like def.
                 const typeBindings = scope.typeBindings;
-                for (const sibling of bucket.moduleScopes) {
-                    if (sibling.filePath === filePath)
+                const mergePaths = truncated ? injectedPaths : allSiblingPaths;
+                // Module scopes first, then class scopes: module-level bindings win on
+                // a name collision, which the two-pass order (not file order) encodes.
+                for (const siblingPath of mergePaths) {
+                    if (siblingPath === filePath)
+                        continue;
+                    const sibling = moduleScopeByPath.get(siblingPath);
+                    if (sibling === undefined)
                         continue;
                     for (const [name, ref] of sibling.scope.typeBindings) {
                         if (!typeBindings.has(name))
                             typeBindings.set(name, ref);
                     }
                 }
-                for (const sibling of bucket.parsed) {
-                    if (sibling.filePath === filePath)
+                for (const siblingPath of mergePaths) {
+                    if (siblingPath === filePath)
+                        continue;
+                    const sibling = parsedByPath.get(siblingPath);
+                    if (sibling === undefined)
                         continue;
                     for (const siblingScope of sibling.scopes) {
                         if (siblingScope.kind !== 'Class')
@@ -110,15 +174,19 @@ export function createJvmPackageSiblingVisibility(options) {
                 }
             }
         }
+        if (truncatedFiles > 0) {
+            logger.warn(`[${options.languageLabel}-package-siblings] sibling injection truncated at ${maxInjectedSiblings} per file for ${truncatedFiles} file(s); wildcard attribution disabled for those files (raise or unset GITNEXUS_MAX_INJECTED_SIBLINGS to widen, 0 for unbounded)`);
+        }
     }
     return {
         populateNamespaceSiblings,
         isVisibilityIncomplete: (filePath) => incompleteFiles.has(filePath),
     };
 }
-function sharedSegmentCount(a, b) {
-    const aSegments = a.replace(/\\/g, '/').split('/');
-    const bSegments = b.replace(/\\/g, '/').split('/');
+function pathSegments(filePath) {
+    return filePath.replace(/\\/g, '/').split('/');
+}
+function sharedSegmentCount(aSegments, bSegments) {
     let index = 0;
     while (index < aSegments.length &&
         index < bSegments.length &&

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

@@ -39,7 +39,10 @@
 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 { KotlinSpringAopFact } from './spring-aop.js';
+import type { KotlinSpringConditionalFact } from './spring-conditionals.js';
 import type { KotlinSpringDiClassFact } from './spring-di.js';
+import type { KotlinSpringNonHttpHandlerFact } from './spring-non-http-handlers.js';
 /**
  * Plain JSON-serializable snapshot of the per-file Kotlin capture-time
  * side-channel. Carried opaquely on `ParsedFile.captureSideChannel`. The
@@ -54,14 +57,26 @@ export interface KotlinCaptureSideChannel {
     readonly packageFact: JvmPackageFact;
     /** Class annotation syntax collected by the existing scope traversal. */
     readonly classAnnotations: readonly ClassAnnotationFact[];
+    /** Spring proxy/advice syntax captured per class or callable owner. */
+    readonly springAopFacts?: readonly KotlinSpringAopFact[];
+    /** Profile, conditional, and auto-configuration syntax captured per owner. */
+    readonly springConditionalFacts?: readonly KotlinSpringConditionalFact[];
     /** Constructor, property, and method injection syntax captured per class. */
     readonly springDiFacts?: readonly KotlinSpringDiClassFact[];
+    /** Scheduled, event, messaging, and managed-job handler syntax captured per callable. */
+    readonly springNonHttpHandlerFacts?: readonly KotlinSpringNonHttpHandlerFact[];
 }
 export declare function clearKotlinClassAnnotationFacts(): void;
+export declare function setKotlinSpringAopFacts(filePath: string, facts: readonly KotlinSpringAopFact[]): void;
+export declare function getKotlinSpringAopFacts(filePath: string): readonly KotlinSpringAopFact[];
 export declare function setKotlinClassAnnotationFacts(filePath: string, facts: readonly ClassAnnotationFact[]): void;
 export declare function getKotlinClassAnnotationFacts(filePath: string): readonly ClassAnnotationFact[];
+export declare function setKotlinSpringConditionalFacts(filePath: string, facts: readonly KotlinSpringConditionalFact[]): void;
+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 setKotlinSpringNonHttpHandlerFacts(filePath: string, facts: readonly KotlinSpringNonHttpHandlerFact[]): void;
+export declare function getKotlinSpringNonHttpHandlerFacts(filePath: string): readonly KotlinSpringNonHttpHandlerFact[];
 /**
  * `LanguageProvider.collectCaptureSideChannel` implementation for Kotlin.
  * Returns `undefined` when this file recorded no side-channel state at all, so

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

@@ -41,10 +41,25 @@ import { isJvmPackageFact, UNKNOWN_JVM_PACKAGE_FACT, } from '../jvm/package-fact
 import { getCompanionScopesForFile, markCompanionScope } from './companion-scopes.js';
 import { getKotlinPackageFact, setKotlinPackageFact } from './package-facts.js';
 const classAnnotations = createClassAnnotationFactStore();
+const springAopFacts = new Map();
+const springConditionalFacts = new Map();
 const springDiFacts = new Map();
+const springNonHttpHandlerFacts = new Map();
 export function clearKotlinClassAnnotationFacts() {
     classAnnotations.clear();
+    springAopFacts.clear();
+    springConditionalFacts.clear();
     springDiFacts.clear();
+    springNonHttpHandlerFacts.clear();
+}
+export function setKotlinSpringAopFacts(filePath, facts) {
+    if (facts.length === 0)
+        springAopFacts.delete(filePath);
+    else
+        springAopFacts.set(filePath, facts);
+}
+export function getKotlinSpringAopFacts(filePath) {
+    return springAopFacts.get(filePath) ?? [];
 }
 export function setKotlinClassAnnotationFacts(filePath, facts) {
     classAnnotations.set(filePath, facts);
@@ -52,6 +67,15 @@ export function setKotlinClassAnnotationFacts(filePath, facts) {
 export function getKotlinClassAnnotationFacts(filePath) {
     return classAnnotations.get(filePath);
 }
+export function setKotlinSpringConditionalFacts(filePath, facts) {
+    if (facts.length === 0)
+        springConditionalFacts.delete(filePath);
+    else
+        springConditionalFacts.set(filePath, facts);
+}
+export function getKotlinSpringConditionalFacts(filePath) {
+    return springConditionalFacts.get(filePath) ?? [];
+}
 export function setKotlinSpringDiFacts(filePath, facts) {
     if (facts.length === 0)
         springDiFacts.delete(filePath);
@@ -61,6 +85,15 @@ export function setKotlinSpringDiFacts(filePath, facts) {
 export function getKotlinSpringDiFacts(filePath) {
     return springDiFacts.get(filePath) ?? [];
 }
+export function setKotlinSpringNonHttpHandlerFacts(filePath, facts) {
+    if (facts.length === 0)
+        springNonHttpHandlerFacts.delete(filePath);
+    else
+        springNonHttpHandlerFacts.set(filePath, facts);
+}
+export function getKotlinSpringNonHttpHandlerFacts(filePath) {
+    return springNonHttpHandlerFacts.get(filePath) ?? [];
+}
 /**
  * `LanguageProvider.collectCaptureSideChannel` implementation for Kotlin.
  * Returns `undefined` when this file recorded no side-channel state at all, so
@@ -69,11 +102,17 @@ export function getKotlinSpringDiFacts(filePath) {
 export function collectKotlinCaptureSideChannel(filePath) {
     const companionScopes = getCompanionScopesForFile(filePath);
     const annotationFacts = classAnnotations.get(filePath);
+    const aopFacts = springAopFacts.get(filePath) ?? [];
+    const conditionFacts = springConditionalFacts.get(filePath) ?? [];
     const diFacts = springDiFacts.get(filePath) ?? [];
+    const nonHttpHandlerFacts = springNonHttpHandlerFacts.get(filePath) ?? [];
     const packageFact = getKotlinPackageFact(filePath);
     if (companionScopes.length === 0 &&
         annotationFacts.length === 0 &&
+        aopFacts.length === 0 &&
+        conditionFacts.length === 0 &&
         diFacts.length === 0 &&
+        nonHttpHandlerFacts.length === 0 &&
         packageFact === undefined) {
         return undefined;
     }
@@ -82,7 +121,10 @@ export function collectKotlinCaptureSideChannel(filePath) {
         companionScopes,
         packageFact: packageFact ?? UNKNOWN_JVM_PACKAGE_FACT,
         classAnnotations: annotationFacts,
+        ...(aopFacts.length > 0 ? { springAopFacts: aopFacts } : {}),
+        ...(conditionFacts.length > 0 ? { springConditionalFacts: conditionFacts } : {}),
         ...(diFacts.length > 0 ? { springDiFacts: diFacts } : {}),
+        ...(nonHttpHandlerFacts.length > 0 ? { springNonHttpHandlerFacts: nonHttpHandlerFacts } : {}),
     };
 }
 /**
@@ -102,7 +144,10 @@ export function applyKotlinCaptureSideChannel(parsed) {
         !Array.isArray(data.companionScopes) ||
         !Array.isArray(data.classAnnotations)) {
         classAnnotations.set(parsed.filePath, []);
+        setKotlinSpringAopFacts(parsed.filePath, []);
+        setKotlinSpringConditionalFacts(parsed.filePath, []);
         setKotlinSpringDiFacts(parsed.filePath, []);
+        setKotlinSpringNonHttpHandlerFacts(parsed.filePath, []);
         setKotlinPackageFact(parsed.filePath, UNKNOWN_JVM_PACKAGE_FACT);
         return;
     }
@@ -110,6 +155,9 @@ export function applyKotlinCaptureSideChannel(parsed) {
         markCompanionScope(parsed.filePath, scopeId);
     }
     classAnnotations.set(parsed.filePath, data.classAnnotations);
+    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 : []);
+    setKotlinSpringNonHttpHandlerFacts(parsed.filePath, Array.isArray(data.springNonHttpHandlerFacts) ? data.springNonHttpHandlerFacts : []);
     setKotlinPackageFact(parsed.filePath, isJvmPackageFact(data.packageFact) ? data.packageFact : UNKNOWN_JVM_PACKAGE_FACT);
 }