gitnexus 1.6.6-rc.99 → 1.6.6

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

@@ -55,8 +55,12 @@ export function emitCobolScopeCaptures(sourceText, _filePath, _cachedTree) {
         const startCol = 0;
         const endCol = endColFrom(lines[Math.min(endLine, lines.length) - 1] ?? '');
         const progIdLine = findProgramIdLine(cleaned, name);
+        // Determine PROGRAM-ID name column: free-format has no fixed column;
+        // fixed-format uses column 7 (after 6-char sequence area replaced by preprocessing)
+        const isFreeFormat = />>SOURCE\s+(?:FORMAT\s+(?:IS\s+)?)?FREE/i.test(cleaned);
+        const nameCol = isFreeFormat ? findProgramIdNameColumn(lines, progIdLine) : 7;
         const nameRange = progIdLine !== -1
-            ? rangeOf(progIdLine, 7, progIdLine, lines[progIdLine - 1]?.length ?? endCol)
+            ? rangeOf(progIdLine, nameCol, progIdLine, lines[progIdLine - 1]?.length ?? endCol)
             : rangeOf(startLine, startCol, endLine, endCol);
         const grouped = {
             '@scope.module': capture('@scope.module', rangeOf(startLine, startCol, endLine, endCol), name),
@@ -79,8 +83,10 @@ export function emitCobolScopeCaptures(sourceText, _filePath, _cachedTree) {
         const startCol = 0;
         const endCol = endColFrom(lines[Math.min(endLine, lines.length) - 1] ?? '');
         const progIdLine = findProgramIdLine(cleaned, prog.name);
+        const isFreeFormatNested = />>SOURCE\s+(?:FORMAT\s+(?:IS\s+)?)?FREE/i.test(cleaned);
+        const nameColNested = isFreeFormatNested ? findProgramIdNameColumn(lines, progIdLine) : 7;
         const nameRange = progIdLine !== -1
-            ? rangeOf(progIdLine, 7, progIdLine, lines[progIdLine - 1]?.length ?? endCol)
+            ? rangeOf(progIdLine, nameColNested, progIdLine, lines[progIdLine - 1]?.length ?? endCol)
             : rangeOf(startLine, startCol, endLine, endCol);
         const grouped = {
             '@scope.module': capture('@scope.module', rangeOf(startLine, startCol, endLine, endCol), prog.name),
@@ -225,3 +231,20 @@ function findProgramIdLine(cleanedSource, programName) {
 function escapeRegex(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+/**
+ * Find the column position of the program name on the PROGRAM-ID line.
+ * Searches for `PROGRAM-ID. name` and returns the column where name starts.
+ * Returns 0 as fallback if the line can't be parsed (the range will be
+ * from column 0 which is still valid for capture bounds).
+ */
+function findProgramIdNameColumn(lines, lineNum) {
+    if (lineNum < 1 || lineNum > lines.length)
+        return 0;
+    const line = lines[lineNum - 1];
+    const m = line.match(/\bPROGRAM-ID\.\s+([A-Z0-9][A-Z0-9-]*)/i);
+    if (!m || m.index === undefined)
+        return 0;
+    // Column = index of start of capture group 1
+    const nameStart = m.index + m[0].length - m[1].length;
+    return nameStart;
+}

package/dist/core/ingestion/languages/cpp/adl.d.ts

@@ -49,13 +49,18 @@
  *
  * ## State lifecycle
  *
- * Three module-level maps populated per pipeline invocation, cleared via
- * `clearCppAdlState()` (called from `clearFileLocalNames`):
+ * Five pieces of module-level state populated per pipeline invocation, all
+ * reset together by `clearCppAdlState()` (called from
+ * `cppScopeResolver.loadResolutionConfig`, alongside `clearFileLocalNames` —
+ * NOT from `clearFileLocalNames` itself), grouped by when they fill:
  *
  *   - `argInfoBySite` — per-call-site argument shape (capture-time)
  *   - `noAdlSites` — call sites with parenthesized function (capture-time)
  *   - `classToNamespaceQualifiedName` — class def → its enclosing namespace
  *     qualified name (`populateCppAssociatedNamespaces` time)
+ *   - `adlIndex` / `adlIndexSource` — the lazily-built candidate index and the
+ *     `parsedFiles` reference it was built from (first-`pickCppAdlCandidates`
+ *     time; see `ensureAdlIndex`)
  *
  * The class→namespace map uses qualified names (not scope IDs) because
  * C++ namespaces are open: `namespace N { ... }` in file A and
@@ -94,14 +99,93 @@ export interface CppAdlArgInfo {
      *  referenced Function/Method def's parameter and return types. */
     readonly functionRefText?: string;
 }
+/**
+ * ADL candidate index — built **once** per pipeline run from
+ * `(scopes, parsedFiles)` and reused by every call site.
+ *
+ * The legacy `pickCppAdlCandidates` re-scanned all parsed files (rebuilding a
+ * per-file `scopesById` map each time), all workspace defs (for the
+ * class-by-simple-name lookup), and used an O(scopes²) child-scope walk for
+ * hidden friends — once **per unresolved call site**. With hundreds of
+ * thousands of unresolved C++ sites that made the scope-resolution emit phase
+ * super-linear (observed ~6.7h on a large repo). This index moves all of that
+ * work to a single pass; per-site cost drops to O(associated namespaces).
+ */
+export interface AdlCandidateIndex {
+    /** simple name → class-like defs (Class/Struct/Interface/Enum), preserving
+     *  `scopes.defs.byId` iteration order so first-match / ambiguous semantics
+     *  match the legacy linear scan. */
+    readonly classDefsBySimple: Map<string, SymbolDefinition[]>;
+    /** namespace QName → simple name → callable defs owned by that namespace,
+     *  with inline-namespace transparency (inline-ns defs are also registered
+     *  under the parent namespace's QName). */
+    readonly nsCandidates: Map<string, Map<string, SymbolDefinition[]>>;
+    /** associated-class enclosing-namespace QName → simple name → hidden-friend
+     *  and class-member callable defs. */
+    readonly friendCandidates: Map<string, Map<string, SymbolDefinition[]>>;
+    /** namespace QName (own) → simple name → Function/Method defs, for the
+     *  qualified function-reference ADL path. */
+    readonly nsFunctionsByQName: Map<string, Map<string, SymbolDefinition[]>>;
+    /** simple name → Function/Method defs across all namespaces, for the
+     *  unqualified function-reference ADL path. */
+    readonly nsFunctionsBySimple: Map<string, SymbolDefinition[]>;
+    /** nodeId → visitation sequence number, used to merge per-namespace buckets
+     *  back into the exact legacy candidate order (file-major; namespace defs
+     *  before friend/member defs within a file). */
+    readonly seqByNodeId: Map<string, number>;
+}
+/**
+ * Return the nodeIds present in the index's candidate buckets
+ * (`nsCandidates` + `friendCandidates`) but missing from `seqByNodeId`, each
+ * reported once. Empty array means the seq-coverage invariant holds — which it
+ * must, since `buildAdlIndex` assigns a seq to every callable def in the same
+ * block that buckets it. Exported for the dev-gated guard in `buildAdlIndex`
+ * and its unit test.
+ */
+export declare function validateAdlSeqCoverage(idx: AdlCandidateIndex): string[];
 /** Record per-call-site argument info. Called once per call site from
  *  `emitCppScopeCaptures`. */
 export declare function markCppAdlSiteArgs(filePath: string, line: number, col: number, args: readonly CppAdlArgInfo[]): void;
 /** Mark a call site as ADL-suppressed (function child wrapped in
  *  `parenthesized_expression`, e.g. `(f)(s)`). */
 export declare function markCppAdlSiteNoAdl(filePath: string, line: number, col: number): void;
-/** Clear ADL state. Called from `clearFileLocalNames` so all C++ resolver
- *  per-pipeline state is reset together. */
+/**
+ * Plain-data, JSON-serializable snapshot of the per-file ADL capture state
+ * (`argInfoBySite` entries for this file + `noAdlSites` keys for this file).
+ * Carried on `ParsedFile.captureSideChannel` across the worker→main boundary
+ * (#1983); the call-site key's `line:col` are stored per-entry so the full
+ * `filePath:line:col` key can be reconstructed without parsing.
+ */
+export interface CppAdlSideChannel {
+    /** Per-call-site arg info: `[line, col, args]` for sites in this file. */
+    readonly argInfoBySite: readonly [number, number, readonly CppAdlArgInfo[]][];
+    /** ADL-suppressed sites in this file: `[line, col]`. */
+    readonly noAdlSites: readonly [number, number][];
+}
+/**
+ * Snapshot this file's ADL capture state for the worker→main side-channel.
+ *
+ * Uses the per-file `argInfoSiteKeysByFile` / `noAdlSiteKeysByFile` indexes to
+ * touch only THIS file's entries — O(entries-for-this-file) — instead of the
+ * old O(all-entries) full scan over `argInfoBySite` / `noAdlSites` (#1983).
+ * The output order, and therefore the serialized JSON shape, is byte-identical
+ * to the old filtered scan: the index records keys in the same insertion order
+ * the maps' own iteration would have yielded for this file, and each key is
+ * indexed exactly once (mark guards on first insert), so the same per-file
+ * subsequence is produced.
+ *
+ * `parseSiteKey` is still used to recover `line:col` from each key, but now
+ * only for this file's keys (a bounded handful), never for the whole batch.
+ */
+export declare function collectCppAdlSideChannel(filePath: string): CppAdlSideChannel;
+/** Restore this file's ADL capture state from the side-channel (no parse).
+ *  Keeps the per-file site-key indexes in lockstep with `argInfoBySite` /
+ *  `noAdlSites` (first-insert-only) so a later `collectCppAdlSideChannel` on
+ *  the same process would still produce a correct, duplicate-free snapshot. */
+export declare function applyCppAdlSideChannel(filePath: string, data: CppAdlSideChannel): void;
+/** Clear ADL state. Called from `cppScopeResolver.loadResolutionConfig`
+ *  (alongside `clearFileLocalNames`) so all C++ resolver per-pipeline state is
+ *  reset together at the start of each resolution pass. */
 export declare function clearCppAdlState(): void;
 /**
  * Walk `parsed.scopes` to record each Class def's enclosing namespace