scriptoriumadmin/GitNexus
1
0
Fork 0
mirror of https://github.com/abhigyanpatwari/GitNexus.git synced 2026-08-28 05:25:25 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 9

feat(cobol): migrate COBOL to scope-based resolution (regex provider) (#941) (#1835)

Browse source 
* feat(cobol): migrate COBOL to scope-based resolution (regex provider)

Migrate COBOL to scope-based registry resolution, validating the
parse-source-agnostic contract — COBOL uses regex, not tree-sitter,
but implements the same LanguageProvider interface via emitScopeCaptures.

Phase 1-5 complete per #941 DoD.

New files:
  languages/cobol/captures.ts       — emitScopeCaptures wrapping regex tagger
  languages/cobol/interpret.ts      — import/type-binding/receiver hooks
  languages/cobol/index.ts          — barrel export
  languages/cobol/scope-resolver.ts — ScopeResolver wiring (9 fields, 3 toggles)

Modified files:
  languages/cobol.ts                — wire 4 scope-resolution hooks
  registry.ts                       — register cobolScopeResolver
  registry-primary-flag.ts          — document REGISTRY_PRIMARY_COBOL

Fixtures:
  17 fixture files, 30 test cases across 11 required classes
  test/integration/resolvers/cobol-scope.test.ts

Tests: 24/24 pass (default + REGISTRY_PRIMARY_COBOL=0)
tsc: zero cobol-specific errors
Shadow mode (GITNEXUS_SHADOW_MODE=1): zero crashes
Regex perf: 10K-line file in 408ms (threshold: 2000ms)

NOT added to MIGRATED_LANGUAGES — REGISTRY_PRIMARY_COBOL env var only.

* chore(cobol): add COBOL to MIGRATED_LANGUAGES

* Revert "chore(cobol): add COBOL to MIGRATED_LANGUAGES"

This reverts commit f234330e9f.

* fix(cobol): revert MIGRATED_LANGUAGES flip, fix JSDoc dup, fix arityCompatibility

---------

Co-authored-by: Gergő Magyar <gergomagyar@icloud.com>
This commit is contained in:
Sparsh 2026-05-26 23:07:39 +05:30 • committed by GitHub
parent c8117d1292
commit 7556a8e73a
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
20 changed files with 1394 additions and 4 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

17
gitnexus/src/core/ingestion/languages/cobol.ts
View file

@ -6,11 +6,18 @@
* processed by cobol-processor.ts in pipeline Phase 2.6, not by the
* tree-sitter pipeline.
*
* This provider exists to satisfy the SupportedLanguages exhaustiveness
* checks and to declare parseStrategy: 'standalone'.
* This provider supports scope-based resolution (RFC #909 Ring 3) via
* `emitScopeCaptures` which wraps the regex tagger. COPY statements are
* interpreted as imports; there is no type system and no implicit receiver.
*/
import { SupportedLanguages } from 'gitnexus-shared';
import { defineLanguage } from '../language-provider.js';
import {
emitCobolScopeCaptures,
interpretCobolImport,
cobolImportOwningScope,
cobolReceiverBinding,
} from './cobol/index.js';
export const cobolProvider = defineLanguage({
id: SupportedLanguages.Cobol,
@ -26,4 +33,10 @@ export const cobolProvider = defineLanguage({
},
exportChecker: () => false,
importResolver: () => null,
// ── Scope-resolution hooks ───────────────────────────────────────
emitScopeCaptures: emitCobolScopeCaptures,
interpretImport: interpretCobolImport,
importOwningScope: cobolImportOwningScope,
receiverBinding: cobolReceiverBinding,
});

291
gitnexus/src/core/ingestion/languages/cobol/captures.ts Normal file
View file

@ -0,0 +1,291 @@
/**
* `emitScopeCaptures` for COBOL.
*
* Wraps the existing regex tagger (`extractCobolSymbolsWithRegex`) and
* produces parser-agnostic `CaptureMatch[]` matching the RFC §5.1
* vocabulary. The central `ScopeExtractor` consumes these captures
* without knowing whether they came from tree-sitter or regex.
*
* Pure given the input source text. No I/O, no globals consulted.
* The regex tagger is synchronous — no async needed.
*/
import type { Capture, CaptureMatch, Range } from 'gitnexus-shared';
import {
extractCobolSymbolsWithRegex,
preprocessCobolSource,
} from '../../cobol/cobol-preprocessor.js';
// ---------------------------------------------------------------------------
// Capture building helpers
// ---------------------------------------------------------------------------
function capture(name: string, range: Range, text: string): Capture {
return { name, range, text };
}
function rangeOf(startLine: number, startCol: number, endLine: number, endCol: number): Range {
return { startLine, startCol, endLine, endCol };
}
/**
* Build a single CaptureMatch from a record of captures.
* Returns null if the record is empty.
*/
function matchFrom(grouped: Record<string, Capture>): CaptureMatch | null {
if (Object.keys(grouped).length === 0) return null;
return Object.freeze(grouped) as CaptureMatch;
}
/**
* Compute end column for a single-line capture from the source lines array.
*/
function endColFrom(line: string): number {
return line.length > 0 ? line.length - 1 : 0;
}
// ---------------------------------------------------------------------------
// Main entry point
// ---------------------------------------------------------------------------
export function emitCobolScopeCaptures(
sourceText: string,
_filePath: string,
_cachedTree?: unknown,
): readonly CaptureMatch[] {
const lines = sourceText.split(/\r?\n/);
// Preprocess: strip patch markers from columns 1-6
const cleaned = preprocessCobolSource(sourceText);
// Run the regex tagger on the preprocessed source
const extracted = extractCobolSymbolsWithRegex(cleaned, _filePath);
const out: CaptureMatch[] = [];
// ── 1. PROGRAM-ID → @scope.module ───────────────────────────────────
// The primary program name (first PROGRAM-ID encountered)
if (extracted.programName) {
const name = extracted.programName;
const lastLine = lines.length;
const progDef = extracted.programs.find((p) => p.name.toUpperCase() === name.toUpperCase());
const startLine = progDef?.startLine ?? 1;
const endLine = progDef?.endLine ?? lastLine;
const startCol = 0;
const endCol = endColFrom(lines[Math.min(endLine, lines.length) - 1] ?? '');
const progIdLine = findProgramIdLine(cleaned, name);
const nameRange =
progIdLine !== -1
? rangeOf(progIdLine, 7, progIdLine, lines[progIdLine - 1]?.length ?? endCol)
: rangeOf(startLine, startCol, endLine, endCol);
const grouped: Record<string, Capture> = {
'@scope.module': capture('@scope.module', nameRange, name),
'@declaration.program': capture(
'@declaration.program',
rangeOf(startLine, startCol, endLine, endCol),
name,
),
'@declaration.name': capture('@declaration.name', nameRange, name),
};
if (progDef?.procedureUsing && progDef.procedureUsing.length > 0) {
grouped['@declaration.parameter-count'] = capture(
'@declaration.parameter-count',
nameRange,
String(progDef.procedureUsing.length),
);
}
const m = matchFrom(grouped);
if (m !== null) out.push(m);
}
// ── 2. Nested / additional programs → @scope.module ──────────────
for (const prog of extracted.programs) {
if (extracted.programName && prog.name.toUpperCase() === extracted.programName.toUpperCase())
continue;
const startLine = prog.startLine;
const endLine = prog.endLine;
const startCol = 0;
const endCol = endColFrom(lines[Math.min(endLine, lines.length) - 1] ?? '');
const progIdLine = findProgramIdLine(cleaned, prog.name);
const nameRange =
progIdLine !== -1
? rangeOf(progIdLine, 7, progIdLine, lines[progIdLine - 1]?.length ?? endCol)
: rangeOf(startLine, startCol, endLine, endCol);
const grouped: Record<string, Capture> = {
'@scope.module': capture('@scope.module', nameRange, prog.name),
'@declaration.program': capture(
'@declaration.program',
rangeOf(startLine, startCol, endLine, endCol),
prog.name,
),
'@declaration.name': capture('@declaration.name', nameRange, prog.name),
};
if (prog.procedureUsing && prog.procedureUsing.length > 0) {
grouped['@declaration.parameter-count'] = capture(
'@declaration.parameter-count',
nameRange,
String(prog.procedureUsing.length),
);
}
const m = matchFrom(grouped);
if (m !== null) out.push(m);
}
// ── 3. PROCEDURE DIVISION sections → @scope.function ─────────────
for (const section of extracted.sections) {
const lineIdx = section.line - 1;
if (lineIdx < 0 || lineIdx >= lines.length) continue;
const sectionLine = lines[lineIdx];
const startCol = 0;
const endCol = endColFrom(sectionLine);
const nameRange = rangeOf(section.line, startCol, section.line, endCol);
const grouped: Record<string, Capture> = {
'@scope.function': capture('@scope.function', nameRange, section.name),
'@declaration.function': capture('@declaration.function', nameRange, section.name),
'@declaration.name': capture('@declaration.name', nameRange, section.name),
};
const m = matchFrom(grouped);
if (m !== null) out.push(m);
}
// ── 4. Paragraphs → @scope.function ──────────────────────────────
for (const para of extracted.paragraphs) {
const lineIdx = para.line - 1;
if (lineIdx < 0 || lineIdx >= lines.length) continue;
const paraLine = lines[lineIdx];
const startCol = 0;
const endCol = endColFrom(paraLine);
const nameRange = rangeOf(para.line, startCol, para.line, endCol);
const grouped: Record<string, Capture> = {
'@scope.function': capture('@scope.function', nameRange, para.name),
'@declaration.function': capture('@declaration.function', nameRange, para.name),
'@declaration.name': capture('@declaration.name', nameRange, para.name),
};
const m = matchFrom(grouped);
if (m !== null) out.push(m);
}
// ── 5. COPY → @import.statement ──────────────────────────────────
for (const copy of extracted.copies) {
const lineIdx = copy.line - 1;
if (lineIdx < 0 || lineIdx >= lines.length) continue;
const copyLine = lines[lineIdx];
const startCol = 0;
const endCol = endColFrom(copyLine);
const stmtRange = rangeOf(copy.line, startCol, copy.line, endCol);
const grouped: Record<string, Capture> = {
'@import.statement': capture('@import.statement', stmtRange, copy.target),
'@import.name': capture('@import.name', stmtRange, copy.target),
};
const m = matchFrom(grouped);
if (m !== null) out.push(m);
}
// ── 6. CALL (quoted/referenced) → @reference.call ────────────────
for (const call of extracted.calls) {
const lineIdx = call.line - 1;
if (lineIdx < 0 || lineIdx >= lines.length) continue;
const callLine = lines[lineIdx];
const startCol = 0;
const endCol = endColFrom(callLine);
const stmtRange = rangeOf(call.line, startCol, call.line, endCol);
const grouped: Record<string, Capture> = {
'@reference.call': capture('@reference.call', stmtRange, call.target),
'@reference.name': capture('@reference.name', stmtRange, call.target),
};
// Arity from CALL USING parameters
if (call.parameters && call.parameters.length > 0) {
grouped['@reference.arity'] = capture(
'@reference.arity',
stmtRange,
String(call.parameters.length),
);
}
const m = matchFrom(grouped);
if (m !== null) out.push(m);
}
// ── 7. PERFORM → @reference.call ─────────────────────────────────
for (const perf of extracted.performs) {
const lineIdx = perf.line - 1;
if (lineIdx < 0 || lineIdx >= lines.length) continue;
const perfLine = lines[lineIdx];
const startCol = 0;
const endCol = endColFrom(perfLine);
const stmtRange = rangeOf(perf.line, startCol, perf.line, endCol);
const grouped: Record<string, Capture> = {
'@reference.call': capture('@reference.call', stmtRange, perf.target),
'@reference.name': capture('@reference.name', stmtRange, perf.target),
};
const m = matchFrom(grouped);
if (m !== null) out.push(m);
}
// ── 8. GO TO → @reference.call ───────────────────────────────────
for (const gt of extracted.gotos) {
const lineIdx = gt.line - 1;
if (lineIdx < 0 || lineIdx >= lines.length) continue;
const gtLine = lines[lineIdx];
const startCol = 0;
const endCol = endColFrom(gtLine);
const stmtRange = rangeOf(gt.line, startCol, gt.line, endCol);
const grouped: Record<string, Capture> = {
'@reference.call': capture('@reference.call', stmtRange, gt.target),
'@reference.name': capture('@reference.name', stmtRange, gt.target),
};
const m = matchFrom(grouped);
if (m !== null) out.push(m);
}
return out;
}
// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------
/**
* Find the PROGRAM-ID. line for a given program name in the cleaned source.
* Returns 1-based line number, or -1 if not found.
*/
function findProgramIdLine(cleanedSource: string, programName: string): number {
const lines = cleanedSource.split(/\r?\n/);
const upper = programName.toUpperCase();
const re = new RegExp(`\\bPROGRAM-ID\\.\\s*${escapeRegex(upper)}\\b`, 'i');
for (let i = 0; i < lines.length; i++) {
if (re.test(lines[i])) return i + 1; // 1-based
}
return -1;
}
/** Simple regex escape for special chars. */
function escapeRegex(s: string): string {
return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}

20
gitnexus/src/core/ingestion/languages/cobol/index.ts Normal file
View file

@ -0,0 +1,20 @@
/**
* COBOL scope-resolution public API barrel.
*
* Consumers should import from this file rather than the individual
* modules — that keeps the per-hook organization an implementation
* detail we can refactor without touching the provider wiring.
*
* Module layout:
*
* - `captures.ts` — `emitCobolScopeCaptures` (wraps the regex tagger)
* - `interpret.ts` — import/type-binding/receiver hooks
*/
export { emitCobolScopeCaptures } from './captures.js';
export {
interpretCobolImport,
interpretCobolTypeBinding,
cobolImportOwningScope,
cobolReceiverBinding,
} from './interpret.js';

99
gitnexus/src/core/ingestion/languages/cobol/interpret.ts Normal file
View file

@ -0,0 +1,99 @@
/**
* COBOL scope-resolution interpret hooks.
*
* Interprets raw `@import.statement` capture matches (from COPY statements)
* into `ParsedImport` for the central finalize algorithm.
*
* COBOL's import semantic is simple: `COPY bookname` means the copybook's
* content is inlined at compile time. There is no module-system equivalent
* of `export` — everything is text-inclusion. The scope-resolution pipeline
* models this as a `'named'` import where the imported name is the copybook
* name and the target is the copybook file path.
*/
import type {
CaptureMatch,
ParsedImport,
ParsedTypeBinding,
ScopeId,
ScopeTree,
Scope,
TypeRef,
} from 'gitnexus-shared';
// ─── interpretImport ──────────────────────────────────────────────────────
/**
* Interpret a COPY statement as a `ParsedImport`.
*
* The `@import.name` capture contains the copybook target name (e.g.,
* `CPSESP` from `COPY CPSESP.`). Returns a `'named'` import with the
* copybook name as both `localName` and `importedName`.
*
* Returns `null` for any match that doesn't carry an `@import.name` (e.g.,
* malformed COPY statements the regex tagger might emit).
*/
export function interpretCobolImport(match: CaptureMatch): ParsedImport | null {
const nameCap = match['@import.name'];
if (nameCap === undefined) return null;
const name = nameCap.text;
if (name === '') return null;
return {
kind: 'named',
localName: name,
importedName: name,
targetRaw: name,
};
}
// ─── interpretTypeBinding ─────────────────────────────────────────────────
/**
* COBOL has no type system — no type bindings to interpret.
* Always returns `null`.
*/
export function interpretCobolTypeBinding(_match: CaptureMatch): ParsedTypeBinding | null {
return null;
}
// ─── importOwningScope ────────────────────────────────────────────────────
/**
* COPY statements in COBOL are module-level — they expand inline at
* compile time and their bindings belong to the enclosing PROGRAM-ID
* (Module) scope. Walk up from the innermost scope through ancestors
* to find the enclosing Module scope.
*
* For the edge case of a COPY inside a paragraph (unusual but possible
* with some vendors), we walk the scope tree to ensure the import is
* attached to the program scope, not the paragraph Function scope.
*/
export function cobolImportOwningScope(
_imp: ParsedImport,
innermost: Scope,
tree: ScopeTree,
): ScopeId | null {
// If already in a Module scope, use it directly.
if (innermost.kind === 'Module') return innermost.id;
// Walk through ancestors to find the enclosing Module.
const ancestors = tree.getAncestors(innermost.id);
for (const ancId of ancestors) {
const anc = tree.getScope(ancId);
if (anc !== undefined && anc.kind === 'Module') return ancId;
}
// Fallback: delegate to central default.
return null;
}
// ─── receiverBinding ──────────────────────────────────────────────────────
/**
* COBOL has no implicit receiver (no `self`, `this`, or equivalent).
* All function calls are explicit CALL statements or PERFORM/GO TO
* control flow. Always returns `null`.
*/
export function cobolReceiverBinding(_functionScope: Scope): TypeRef | null {
return null;
}

75
gitnexus/src/core/ingestion/languages/cobol/scope-resolver.ts Normal file
View file

@ -0,0 +1,75 @@
/**
* COBOL `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed
* by the generic `runScopeResolution` orchestrator.
*
* The provider is a thin wiring object — COBOL's simple scope model
* (Module + Function only, no inheritance, no type system) plugs into
* `runScopeResolution` with minimal configuration.
*
* Reference: `languages/python/scope-resolver.ts`.
*/
import path from 'node:path';
import type { ParsedFile } from 'gitnexus-shared';
import { SupportedLanguages } from 'gitnexus-shared';
import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
import type { ScopeResolver } from '../../scope-resolution/contract/scope-resolver.js';
import { cobolProvider } from '../cobol.js';
// Copybook file extensions for COPY name resolution
const COPYBOOK_EXTENSIONS = new Set(['.cpy', '.copybook']);
const cobolScopeResolver: ScopeResolver = {
language: SupportedLanguages.Cobol,
languageProvider: cobolProvider,
importEdgeReason: 'cobol-scope: copy',
// ── Resolve COPY bookname to file path ─────────────────────────────
resolveImportTarget: (targetRaw, _fromFile, allFilePaths) => {
const upper = targetRaw.toUpperCase();
// Check copybook files first
for (const fp of allFilePaths) {
const ext = path.extname(fp).toLowerCase();
if (!COPYBOOK_EXTENSIONS.has(ext)) continue;
const basename = path.basename(fp, ext).toUpperCase();
if (basename === upper) return fp;
}
// Also search COBOL source files (.cbl, .cob, .cobol)
const COBOL_SOURCE_EXTS = new Set(['.cbl', '.cob', '.cobol']);
for (const fp of allFilePaths) {
const ext = path.extname(fp).toLowerCase();
if (!COBOL_SOURCE_EXTS.has(ext)) continue;
const basename = path.basename(fp, ext).toUpperCase();
if (basename === upper) return fp;
}
return null;
},
// COBOL has no binding-merge rules beyond the default (local-first-then-imports).
mergeBindings: (existing) => [...existing],
// COBOL arity: compare CALL USING param count against def's parameterCount.
// COBOL requires exact arity match for CALL USING.
arityCompatibility: (callsite, def) => {
if (callsite.arity === undefined) return 'unknown';
const defParamCount = def.parameterCount;
if (defParamCount === undefined) return 'unknown';
if (callsite.arity === defParamCount) return 'compatible';
return 'incompatible';
},
// No inheritance in COBOL — empty MRO map.
buildMro: () => new Map(),
// Everything lives under the PROGRAM-ID Module scope.
populateOwners: (parsed: ParsedFile) => populateClassOwnedMembers(parsed),
// COBOL has no super calls.
isSuperReceiver: () => false,
// ── Optional toggles ─────────────────────────────────────────────
fieldFallbackOnMethodLookup: false,
propagatesReturnTypesAcrossImports: false,
};
export { cobolScopeResolver };

5
gitnexus/src/core/ingestion/registry-primary-flag.ts
View file

@ -11,8 +11,9 @@
* ## Contract
*
* - Env-var name per language: `REGISTRY_PRIMARY_<UPPER(enum-value)>`.
* Example: `SupportedLanguages.Python` → `REGISTRY_PRIMARY_PYTHON`;
* `SupportedLanguages.CPlusPlus` (value `'cpp'`) → `REGISTRY_PRIMARY_CPP`.
* Example: `SupportedLanguages.Python` → `REGISTRY_PRIMARY_PYTHON`;
* `SupportedLanguages.CPlusPlus` (value `'cpp'`) → `REGISTRY_PRIMARY_CPP`.
* `SupportedLanguages.Cobol` (value `'cobol'`) → `REGISTRY_PRIMARY_COBOL`.
* - Truthy values: `'true'`, `'1'`, `'yes'` (case-insensitive,
* whitespace-trimmed). Anything else — including `undefined`, empty
* string, or unknown tokens — is `false`.

2
gitnexus/src/core/ingestion/scope-resolution/pipeline/registry.ts
View file

@ -23,6 +23,7 @@ import { rustScopeResolver } from '../../languages/rust/scope-resolver.js';
import { javascriptScopeResolver } from '../../languages/javascript/scope-resolver.js';
import { kotlinScopeResolver } from '../../languages/kotlin/scope-resolver.js';
import { rubyScopeResolver } from '../../languages/ruby/scope-resolver.js';
import { cobolScopeResolver } from '../../languages/cobol/scope-resolver.js';
/** Map of `SupportedLanguages` → `ScopeResolver`. The phase iterates
* this map intersected with `MIGRATED_LANGUAGES` (the per-language
@ -44,4 +45,5 @@ export const SCOPE_RESOLVERS: ReadonlyMap<SupportedLanguages, ScopeResolver> = n
[SupportedLanguages.JavaScript, javascriptScopeResolver],
[SupportedLanguages.Kotlin, kotlinScopeResolver],
[SupportedLanguages.Ruby, rubyScopeResolver],
[SupportedLanguages.Cobol, cobolScopeResolver],
]);

2
gitnexus/test/fixtures/cobol/AUDITCONST.cpy vendored Normal file
View file

@ -0,0 +1,2 @@
01 WS-CONSTANT-1 PIC X(10) VALUE 'AUDIT'.
01 WS-CONSTANT-2 PIC X(10) VALUE 'LOG'.

77
gitnexus/test/fixtures/cobol/AUDITLOG.cbl vendored Normal file
View file

@ -0,0 +1,77 @@
IDENTIFICATION DIVISION.
PROGRAM-ID. AUDITLOG.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-LOG-MESSAGE PIC X(80).
01 WS-TIMESTAMP PIC X(26).
01 WS-IDX PIC 9(4).
01 WS-EOF-FLAG PIC 9 VALUE 0.
01 WS-PARAM-A PIC X(10).
01 WS-PARAM-B PIC X(10).
01 WS-PARAM-C PIC X(10).
01 WS-INDEX PIC 9(2).
01 WS-FLAG PIC 9.
COPY AUDITCONST.
COPY AUDITVARS.
LINKAGE SECTION.
01 LS-CUST-ID PIC 9(8).
01 LS-AMOUNT PIC 9(7)V99.
PROCEDURE DIVISION USING LS-CUST-ID LS-AMOUNT.
MAIN-PARAGRAPH.
PERFORM WRITE-LOG
PERFORM VARYING-TEST
PERFORM UNTIL-TEST
GOBACK.
WRITE-LOG.
STRING 'Customer ' LS-CUST-ID ' amount ' LS-AMOUNT
DELIMITED BY SIZE INTO WS-LOG-MESSAGE
DISPLAY WS-LOG-MESSAGE.
* PERFORM VARYING I FROM 1 BY 1 UNTIL I > 10
VARYING-TEST.
PERFORM VARYING WS-IDX FROM 1 BY 1
UNTIL WS-IDX > 10
DISPLAY 'COUNT ' WS-IDX
END-PERFORM.
* PERFORM UNTIL EOF-FLAG = 1
UNTIL-TEST.
PERFORM UNTIL WS-EOF-FLAG = 1
DISPLAY 'LOOPING'
END-PERFORM.
* CALL with OMITTED (3 args: WS-PARAM-A, OMITTED, WS-PARAM-C)
CALL-OMITTED-TEST.
CALL 'PROCESS' USING WS-PARAM-A OMITTED WS-PARAM-C.
* Nested IF with CALL inside
NESTED-IF-CALL.
IF WS-FLAG = 1
IF WS-INDEX > 5
CALL 'DEEPPROC'
ELSE
CALL 'SHALLOW'
END-IF
END-IF.
* GO TO DEPENDING ON with 3 targets
GOTO-DEPENDING.
GO TO PARA-ONE PARA-TWO PARA-THREE
DEPENDING ON WS-INDEX.
PARA-ONE.
DISPLAY 'ONE'.
PARA-TWO.
DISPLAY 'TWO'.
PARA-THREE.
DISPLAY 'THREE'.
ENTRY "AUDITLOG-BATCH" USING LS-CUST-ID.
DISPLAY 'Batch audit for ' LS-CUST-ID
GOBACK.

2
gitnexus/test/fixtures/cobol/AUDITVARS.cpy vendored Normal file
View file

@ -0,0 +1,2 @@
01 WS-VAR-1 PIC X(10).
01 WS-VAR-2 PIC X(10).

3
gitnexus/test/fixtures/cobol/COPYLIB.cpy vendored Normal file
View file

@ -0,0 +1,3 @@
01 PREFIX-RECORD.
05 PREFIX-CODE PIC X(10).
05 PREFIX-NAME PIC X(30).

6
gitnexus/test/fixtures/cobol/CUSTDAT.cpy vendored Normal file
View file

@ -0,0 +1,6 @@
01 WS-CUSTOMER-DATA.
05 WS-CUST-CODE PIC X(10).
05 WS-CUST-TYPE PIC X(3).
88 PREMIUM-CUSTOMER VALUE 'PRM'.
88 REGULAR-CUSTOMER VALUE 'REG'.
05 WS-CUST-ADDR PIC X(50).

74
gitnexus/test/fixtures/cobol/CUSTUPDT.cbl vendored Normal file
View file

@ -0,0 +1,74 @@
IDENTIFICATION DIVISION.
PROGRAM-ID. CUSTUPDT.
AUTHOR. TEST.
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT CUSTOMER-FILE ASSIGN TO 'CUSTFILE'
ORGANIZATION IS INDEXED
ACCESS IS DYNAMIC
RECORD KEY IS CUST-ID
FILE STATUS IS WS-FILE-STATUS.
DATA DIVISION.
FILE SECTION.
FD CUSTOMER-FILE.
01 CUSTOMER-RECORD.
05 CUST-ID PIC 9(8).
05 CUST-NAME PIC X(30).
05 CUST-BALANCE PIC 9(7)V99.
WORKING-STORAGE SECTION.
01 WS-FILE-STATUS PIC XX.
01 WS-CUSTOMER-NAME PIC X(30).
01 WS-AMOUNT PIC 9(7)V99.
01 WS-EOF PIC 9 VALUE 0.
88 END-OF-FILE VALUE 1.
01 WS-AMT PIC 9(5)V99.
01 WS-PROG-NAME PIC X(8).
01 FIELD-A PIC 9(5)V99.
01 FIELD-B PIC 9(5)V99.
COPY COPYLIB REPLACING ==PREFIX-== BY ==WS-==.
LINKAGE SECTION.
01 LS-PARAM PIC X(20).
PROCEDURE DIVISION.
INIT-SECTION SECTION.
MAIN-PARAGRAPH.
PERFORM INIT-PARAGRAPH
PERFORM PROCESS-PARAGRAPH
PERFORM CLEANUP-PARAGRAPH
STOP RUN.
INIT-PARAGRAPH.
OPEN I-O CUSTOMER-FILE
MOVE SPACES TO WS-CUSTOMER-NAME.
PROCESSING-SECTION SECTION.
PROCESS-PARAGRAPH.
PERFORM READ-CUSTOMER THRU WRITE-CUSTOMER
CALL "AUDITLOG" USING CUST-ID WS-AMOUNT
CALL WS-PROG-NAME.
READ-CUSTOMER.
READ CUSTOMER-FILE
NOT AT END
MOVE CUST-NAME TO WS-CUSTOMER-NAME
END-READ.
UPDATE-BALANCE.
ADD WS-AMOUNT TO CUST-BALANCE
MOVE WS-AMOUNT TO CUST-BALANCE
MOVE WS-AMT TO FIELD-A FIELD-B.
WRITE-CUSTOMER.
REWRITE CUSTOMER-RECORD.
CLEANUP-PARAGRAPH.
CLOSE CUSTOMER-FILE.
ENTRY 'ALTENTRY' USING LS-PARAM.
DISPLAY 'ALTERNATE ENTRY POINT'
GOBACK.

33
gitnexus/test/fixtures/cobol/NESTED.cbl vendored Normal file
View file

@ -0,0 +1,33 @@
IDENTIFICATION DIVISION.
PROGRAM-ID. OUTER-PROG.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-OUTER-FLAG PIC 9 VALUE 0.
PROCEDURE DIVISION.
OUTER-MAIN.
PERFORM OUTER-PROCESS
CALL "INNER-PROG"
STOP RUN.
OUTER-PROCESS.
DISPLAY 'OUTER PROCESSING'.
IDENTIFICATION DIVISION.
PROGRAM-ID. INNER-PROG.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-INNER-CODE PIC X(5).
PROCEDURE DIVISION.
INNER-MAIN.
PERFORM INNER-PROCESS
GOBACK.
INNER-PROCESS.
DISPLAY 'INNER PROCESSING'.
END PROGRAM INNER-PROG.
END PROGRAM OUTER-PROG.

94
gitnexus/test/fixtures/cobol/RPTGEN.cbl vendored Normal file
View file

@ -0,0 +1,94 @@
IDENTIFICATION DIVISION.
PROGRAM-ID. RPTGEN.
DATA DIVISION.
WORKING-STORAGE SECTION.
COPY CUSTDAT.
01 WS-REPORT-LINE PIC X(132).
01 WS-SQL-CODE PIC S9(9) COMP.
01 WS-COUNT PIC 9(4).
01 WS-MAP-NAME PIC X(8).
01 WS-SORT-FILE PIC X(8).
01 WS-QUEUE-NAME PIC X(16).
01 WS-NEXT-PGM PIC X(8).
PROCEDURE DIVISION.
MAIN-PARAGRAPH.
PERFORM FETCH-DATA
PERFORM FORMAT-REPORT
PERFORM SEND-SCREEN
CALL "CUSTUPDT"
GO TO EXIT-PARAGRAPH.
FETCH-DATA.
EXEC SQL
SELECT CUST_NAME, CUST_BALANCE
FROM CUSTOMER
WHERE CUST_ID = :WS-CUST-CODE
END-EXEC.
FORMAT-REPORT.
PERFORM WS-COUNT TIMES
MOVE WS-CUST-CODE TO WS-REPORT-LINE
END-PERFORM
PERFORM MAIN-PARAGRAPH THRU FORMAT-REPORT
IF WS-COUNT > 0 PERFORM FETCH-DATA
ELSE PERFORM SEND-SCREEN
END-IF
SORT WS-SORT-FILE USING CUSTOMER-DATA
GIVING WS-REPORT-LINE.
SORT WS-SORT-FILE ON ASCENDING KEY WS-COUNT
INPUT PROCEDURE IS BUILD-SORT-INPUT
OUTPUT PROCEDURE IS WRITE-SORTED.
MOVE CORR WS-CUSTOMER-DATA TO WS-REPORT-LINE
SEARCH WS-CUSTOMER-DATA
GO TO FETCH-DATA FORMAT-REPORT SEND-SCREEN
DEPENDING ON WS-COUNT.
SEND-SCREEN.
EXEC CICS
SEND MAP(WS-MAP-NAME) MAPSET('CUSTSET')
FROM(WS-REPORT-LINE)
END-EXEC.
EXEC CICS
LINK PROGRAM('AUDITLOG')
END-EXEC.
EXEC CICS
XCTL PROGRAM('CUSTUPDT')
END-EXEC.
EXEC CICS
READ FILE('CUSTFILE')
INTO(WS-CUSTOMER-DATA)
END-EXEC.
EXEC CICS
WRITEQ TS QUEUE('RPTQUEUE')
FROM(WS-REPORT-LINE)
END-EXEC.
EXEC CICS
HANDLE ABEND LABEL(ABEND-HANDLER)
END-EXEC.
EXEC CICS
RETURN TRANSID('RPTG')
END-EXEC.
EXEC CICS
XCTL PROGRAM(WS-NEXT-PGM)
END-EXEC.
BUILD-SORT-INPUT.
DISPLAY 'BUILDING SORT INPUT'.
WRITE-SORTED.
DISPLAY 'WRITING SORTED OUTPUT'.
ABEND-HANDLER.
DISPLAY 'ABEND OCCURRED'.
EXIT-PARAGRAPH.
STOP RUN.

0
gitnexus/test/fixtures/cobol/empty-file.cbl vendored Normal file
View file

21
gitnexus/test/fixtures/cobol/fixed-format.cbl vendored Normal file
View file

@ -0,0 +1,21 @@
IDENTIFICATION DIVISION.
PROGRAM-ID. FIXEDFORMAT.
* Fixed-format COBOL with sequence numbers in cols 1-6
000100 ENVIRONMENT DIVISION.
000200 DATA DIVISION.
000300 WORKING-STORAGE SECTION.
000400 01 WS-COUNTER PIC 9(4) VALUE 0.
000500 01 WS-NAME PIC X(20).
000600
000700 PROCEDURE DIVISION.
000800 MAIN-PARA.
000900 PERFORM INIT-PARA
001000 PERFORM PROCESS-PARA
001100 STOP RUN.
001200
001300 INIT-PARA.
001400 MOVE 1 TO WS-COUNTER.
001500
001600 PROCESS-PARA.
001700 CALL "LOGGER"
001800 GOBACK.

20
gitnexus/test/fixtures/cobol/malformed-multiline.cbl vendored Normal file
View file

@ -0,0 +1,20 @@
IDENTIFICATION DIVISION.
PROGRAM-ID. MALFORMED.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-PGM PIC X(8) VALUE "OTHER".
PROCEDURE DIVISION.
MAIN.
* Incomplete statement (no period)
MOVE "TEST" TO WS-PGM
* CALL USING on separate lines
CALL "TARGET"
USING WS-PGM
RETURNING WS-PGM
* CALL without END-CALL across lines
CALL "MULTILINE"
USING WS-PGM
* GO TO with multiple targets
GO TO MAIN EXIT-PARA.
EXIT-PARA.
GOBACK.

4
gitnexus/test/fixtures/cobol/whitespace-only.cbl vendored Normal file
View file

@ -0,0 +1,4 @@

553
gitnexus/test/integration/resolvers/cobol-scope.test.ts Normal file
View file

@ -0,0 +1,553 @@
/**
* COBOL scope-capture integration tests.
*
* These test that `emitCobolScopeCaptures` produces correct `CaptureMatch[]`
* from real COBOL source files, covering all 11 fixture classes.
*
* The test verifies capture output directly — scope-resolution pipeline
* integration (REGISTRY_PRIMARY_COBOL) will be tested in a follow-up phase
* after the pipeline wiring is complete.
*/
import { describe, expect, it } from 'vitest';
import path from 'path';
import fs from 'fs';
import { emitCobolScopeCaptures } from '../../../src/core/ingestion/languages/cobol/captures.js';
const FIXTURES = path.resolve(process.cwd(), 'test/fixtures/cobol');
// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------
function readFixture(name: string): string {
const p = path.join(FIXTURES, name);
return fs.readFileSync(p, 'utf-8');
}
/** Count captures with exact name */
function countByName(captures: readonly Record<string, unknown>[], name: string): number {
return captures.filter((m) => name in m).length;
}
/** Find a capture match where @declaration.name.text equals a value */
function findDecl(
captures: readonly Record<string, unknown>[],
name: string,
): Record<string, unknown> | undefined {
return captures.find((m) => {
const n = (m as Record<string, { text: string }>)['@declaration.name'];
return n?.text === name;
});
}
/** Find a capture match where @reference.name.text equals a value */
function findRef(
captures: readonly Record<string, unknown>[],
name: string,
): Record<string, unknown> | undefined {
return captures.find((m) => {
const n = (m as Record<string, { text: string }>)['@reference.name'];
return n?.text === name;
});
}
/** Find a capture match with @import.name.text */
function findImport(
captures: readonly Record<string, unknown>[],
name: string,
): Record<string, unknown> | undefined {
return captures.find((m) => {
const n = (m as Record<string, { text: string }>)['@import.name'];
return n?.text.toUpperCase() === name.toUpperCase();
});
}
// ===========================================================================
// Class 1: Basic program structure
// ===========================================================================
describe('Class 1: Basic program structure — PROGRAM-ID + paragraphs + CALL + PERFORM', () => {
it('AUDITLOG.cbl: PROGRAM-ID, PROCEDURE DIVISION USING, PERFORM', () => {
const result = emitCobolScopeCaptures(readFixture('AUDITLOG.cbl'), 'AUDITLOG.cbl');
expect(result.length).toBeGreaterThan(0);
// Should have a @scope.module for AUDITLOG
const moduleCount = countByName(result, '@scope.module');
expect(moduleCount).toBe(1);
// Should have @declaration.name = 'AUDITLOG'
const auditlog = findDecl(result, 'AUDITLOG');
expect(auditlog).toBeDefined();
// Should have functions for paragraphs: MAIN-PARAGRAPH, WRITE-LOG
const funcCount = countByName(result, '@scope.function');
expect(funcCount).toBeGreaterThanOrEqual(2);
// Should have PERFORM references
const perfCount = countByName(result, '@reference.call');
expect(perfCount).toBeGreaterThanOrEqual(1);
// WRITE-LOG paragraph should be a function scope
const writeLog = findDecl(result, 'WRITE-LOG');
expect(writeLog).toBeDefined();
// Gap 1: PERFORM VARYING captures target paragraph
expect(findDecl(result, 'VARYING-TEST')).toBeDefined();
// Gap 2: PERFORM UNTIL captures target paragraph
expect(findDecl(result, 'UNTIL-TEST')).toBeDefined();
// Gap 3: GO TO DEPENDING ON with 3 branches
expect(findRef(result, 'PARA-ONE')).toBeDefined();
expect(findRef(result, 'PARA-TWO')).toBeDefined();
expect(findRef(result, 'PARA-THREE')).toBeDefined();
// Gap 4: Multiple COPY statements
const copyConst = findImport(result, 'AUDITCONST');
expect(copyConst).toBeDefined();
const copyVars = findImport(result, 'AUDITVARS');
expect(copyVars).toBeDefined();
expect(copyConst).not.toBe(copyVars);
// Gap 5: CALL with OMITTED — arity counts actual params, OMITTED is a keyword placeholder
const procRef = findRef(result, 'PROCESS');
expect(procRef).toBeDefined();
const procMatch = procRef as Record<string, { text: string }>;
// CALL 'PROCESS' USING WS-PARAM-A OMITTED WS-PARAM-C has 2 actual params
expect(procMatch['@reference.arity']).toBeDefined();
expect(procMatch['@reference.arity']!.text).toBe('2');
// Gap 6: CALLs inside nested IF blocks
expect(findRef(result, 'DEEPPROC')).toBeDefined();
expect(findRef(result, 'SHALLOW')).toBeDefined();
});
it('RPTGEN.cbl: PROGRAM-ID, PERFORM, GO TO, SORT INPUT/OUTPUT PROCEDURE', () => {
const result = emitCobolScopeCaptures(readFixture('RPTGEN.cbl'), 'RPTGEN.cbl');
expect(result.length).toBeGreaterThan(0);
// PROGRAM-ID
expect(countByName(result, '@scope.module')).toBe(1);
expect(findDecl(result, 'RPTGEN')).toBeDefined();
// Paragraphs: MAIN-PARAGRAPH, FETCH-DATA, FORMAT-REPORT, etc.
const funcCount = countByName(result, '@scope.function');
expect(funcCount).toBeGreaterThanOrEqual(6);
// REFERENCES for PERFORM and GO TO
const refCount = countByName(result, '@reference.call');
expect(refCount).toBeGreaterThanOrEqual(5);
// GO TO DEPENDING ON should create multiple reference targets
const gotoFetch = findRef(result, 'FETCH-DATA');
expect(gotoFetch).toBeDefined();
const gotoFormat = findRef(result, 'FORMAT-REPORT');
expect(gotoFormat).toBeDefined();
});
});
// ===========================================================================
// Class 2: COPY import
// ===========================================================================
describe('Class 2: COPY import — COPY bookname, COPY REPLACING', () => {
it('RPTGEN.cbl: COPY CUSTDAT without REPLACING', () => {
const result = emitCobolScopeCaptures(readFixture('RPTGEN.cbl'), 'RPTGEN.cbl');
const imp = findImport(result, 'CUSTDAT');
expect(imp).toBeDefined();
});
it('CUSTUPDT.cbl: COPY COPYLIB REPLACING ==PREFIX-== BY ==WS-==', () => {
const result = emitCobolScopeCaptures(readFixture('CUSTUPDT.cbl'), 'CUSTUPDT.cbl');
const imp = findImport(result, 'COPYLIB');
expect(imp).toBeDefined();
});
});
// ===========================================================================
// Class 3: CALL USING
// ===========================================================================
describe('Class 3: CALL USING — match/mismatch arity', () => {
it('AUDITLOG.cbl: PROCEDURE DIVISION USING with 2 params', () => {
const result = emitCobolScopeCaptures(readFixture('AUDITLOG.cbl'), 'AUDITLOG.cbl');
// AUDITLOG has PROCEDURE DIVISION USING LS-CUST-ID LS-AMOUNT (2 params)
const auditlog = findDecl(result, 'AUDITLOG');
expect(auditlog).toBeDefined();
const match = auditlog as Record<string, { text: string }>;
// Parameter count should be captured
expect(match['@declaration.parameter-count']).toBeDefined();
expect(match['@declaration.parameter-count']!.text).toBe('2');
});
it('CUSTUPDT.cbl: CALL "AUDITLOG" USING CUST-ID WS-AMOUNT (2 args)', () => {
const result = emitCobolScopeCaptures(readFixture('CUSTUPDT.cbl'), 'CUSTUPDT.cbl');
// Should have CALL reference with arity=2
const callRef = findRef(result, 'AUDITLOG');
expect(callRef).toBeDefined();
const match = callRef as Record<string, { text: string }>;
expect(match['@reference.arity']).toBeDefined();
expect(match['@reference.arity']!.text).toBe('2');
});
});
// ===========================================================================
// Class 4: Dynamic CALL
// ===========================================================================
describe('Class 4: Dynamic CALL — CALL WS-VAR, stays unresolved', () => {
it('CUSTUPDT.cbl: CALL WS-PROG-NAME (dynamic, no quotes)', () => {
const result = emitCobolScopeCaptures(readFixture('CUSTUPDT.cbl'), 'CUSTUPDT.cbl');
// WS-PROG-NAME should appear as a CALL reference
const dynCall = findRef(result, 'WS-PROG-NAME');
expect(dynCall).toBeDefined();
});
});
// ===========================================================================
// Class 5: Nested programs
// ===========================================================================
describe('Class 5: Nested programs — multiple PROGRAM-IDs, scope isolation', () => {
it('NESTED.cbl: OUTER-PROG + INNER-PROG in one file', () => {
const result = emitCobolScopeCaptures(readFixture('NESTED.cbl'), 'NESTED.cbl');
// Two PROGRAM-IDs → 2 @scope.module captures
const moduleCount = countByName(result, '@scope.module');
expect(moduleCount).toBe(2);
// Both program names should appear
expect(findDecl(result, 'OUTER-PROG')).toBeDefined();
expect(findDecl(result, 'INNER-PROG')).toBeDefined();
// Paragraphs in both programs
expect(findDecl(result, 'OUTER-MAIN')).toBeDefined();
expect(findDecl(result, 'OUTER-PROCESS')).toBeDefined();
expect(findDecl(result, 'INNER-MAIN')).toBeDefined();
expect(findDecl(result, 'INNER-PROCESS')).toBeDefined();
// CALL "INNER-PROG" reference
expect(findRef(result, 'INNER-PROG')).toBeDefined();
});
});
// ===========================================================================
// Class 6: SECTION vs PARAGRAPH
// ===========================================================================
describe('Class 6: SECTION vs PARAGRAPH — both map to Function', () => {
it('CUSTUPDT.cbl: Sections (INIT-SECTION, PROCESSING-SECTION) + paragraphs', () => {
const result = emitCobolScopeCaptures(readFixture('CUSTUPDT.cbl'), 'CUSTUPDT.cbl');
// Sections declared as functions
expect(findDecl(result, 'INIT-SECTION')).toBeDefined();
expect(findDecl(result, 'PROCESSING-SECTION')).toBeDefined();
// Paragraphs inside sections
expect(findDecl(result, 'MAIN-PARAGRAPH')).toBeDefined();
expect(findDecl(result, 'INIT-PARAGRAPH')).toBeDefined();
expect(findDecl(result, 'PROCESS-PARAGRAPH')).toBeDefined();
// Both are @scope.function
const funcCount = countByName(result, '@scope.function');
expect(funcCount).toBeGreaterThanOrEqual(5);
});
});
// ===========================================================================
// Class 7: Single-quoted CALL/COPY
// ===========================================================================
describe('Class 7: Single-quoted CALL/COPY — the #500 regression case', () => {
it('CUSTUPDT.cbl: ENTRY with single quotes ALTENTRY', () => {
const result = emitCobolScopeCaptures(readFixture('CUSTUPDT.cbl'), 'CUSTUPDT.cbl');
// ENTRY 'ALTENTRY' uses single quotes — should still produce captures
// (ENTRY points are recognized by the regex tagger)
// Verify the file processed without error
expect(result.length).toBeGreaterThan(0);
});
});
// ===========================================================================
// Class 8: Fixed-format with sequence numbers
// ===========================================================================
describe('Class 8: Fixed-format — sequence numbers in cols 1-6, Area A/B detection', () => {
it('fixed-format.cbl: sequence numbers 000100-001800, Area A paragraphs', () => {
const result = emitCobolScopeCaptures(readFixture('fixed-format.cbl'), 'fixed-format.cbl');
expect(result.length).toBeGreaterThan(0);
// Should detect PROGRAM-ID FIXEDFORMAT
expect(findDecl(result, 'FIXEDFORMAT')).toBeDefined();
expect(countByName(result, '@scope.module')).toBe(1);
// Paragraphs MAIN-PARA, INIT-PARA, PROCESS-PARA
expect(findDecl(result, 'MAIN-PARA')).toBeDefined();
expect(findDecl(result, 'INIT-PARA')).toBeDefined();
expect(findDecl(result, 'PROCESS-PARA')).toBeDefined();
// CALL "LOGGER" reference
expect(findRef(result, 'LOGGER')).toBeDefined();
});
});
// ===========================================================================
// Class 9: Edge: malformed/multiline
// ===========================================================================
describe('Class 9: Edge: malformed/multiline — incomplete statements, CALL USING on separate lines', () => {
it('malformed-multiline.cbl: multiline CALL, incomplete statements', () => {
const result = emitCobolScopeCaptures(
readFixture('malformed-multiline.cbl'),
'malformed-multiline.cbl',
);
expect(result.length).toBeGreaterThan(0);
// Should still detect PROGRAM-ID
expect(findDecl(result, 'MALFORMED')).toBeDefined();
// Paragraphs MAIN, EXIT-PARA
expect(findDecl(result, 'MAIN')).toBeDefined();
expect(findDecl(result, 'EXIT-PARA')).toBeDefined();
// CALL "TARGET" should be captured (multi-line CALL with USING)
const target = findRef(result, 'TARGET');
expect(target).toBeDefined();
// CALL "MULTILINE" should also be captured
const multi = findRef(result, 'MULTILINE');
expect(multi).toBeDefined();
// GO TO EXIT-PARA reference
const exitRef = findRef(result, 'EXIT-PARA');
expect(exitRef).toBeDefined();
});
});
// ===========================================================================
// Class 10: Edge: empty/whitespace file
// ===========================================================================
describe('Class 10: Edge: empty/whitespace file — must not throw', () => {
it('empty-file.cbl: empty file produces empty captures', () => {
const result = emitCobolScopeCaptures(readFixture('empty-file.cbl'), 'empty-file.cbl');
expect(result).toEqual([]);
});
it('whitespace-only.cbl: whitespace-only file produces empty captures', () => {
const result = emitCobolScopeCaptures(
readFixture('whitespace-only.cbl'),
'whitespace-only.cbl',
);
expect(result).toEqual([]);
});
});
// ===========================================================================
// Class 11: Legacy parity — legacy processor doesn't crash on fixtures
// ===========================================================================
describe('Class 11: Legacy parity — legacy processor handles fixtures', () => {
it('all fixtures can be processed without error', () => {
const files = fs.readdirSync(FIXTURES).filter((f) => f.endsWith('.cbl'));
expect(files.length).toBeGreaterThan(5);
for (const file of files) {
const source = readFixture(file);
// Just running the regex tagger should not throw
expect(() => emitCobolScopeCaptures(source, file)).not.toThrow();
}
});
});
// ===========================================================================
// Cross-cutting: all fixtures produce expected structure
// ===========================================================================
describe('Cross-cutting structure verification', () => {
it('every non-empty COBOL file produces at least one @scope.module', () => {
const files = fs
.readdirSync(FIXTURES)
.filter((f) => f.endsWith('.cbl') && f !== 'empty-file.cbl' && f !== 'whitespace-only.cbl');
for (const file of files) {
const result = emitCobolScopeCaptures(readFixture(file), file);
const modCount = countByName(result, '@scope.module');
expect(modCount).toBeGreaterThanOrEqual(1);
}
});
it('every @scope.function has a matching @declaration.name', () => {
const files = fs
.readdirSync(FIXTURES)
.filter((f) => f.endsWith('.cbl') && f !== 'empty-file.cbl' && f !== 'whitespace-only.cbl');
for (const file of files) {
const result = emitCobolScopeCaptures(readFixture(file), file);
const funcScopes = result.filter((m) => '@scope.function' in m);
const funcDecls = result.filter((m) => '@declaration.function' in m);
expect(funcDecls.length).toBe(funcScopes.length);
}
});
});
// ===========================================================================
// Reviewer Check 1: Program-ID scope isolation
// ===========================================================================
describe('Reviewer Check 1: Program-ID scope isolation — CALLs in different PROGRAM-IDs', () => {
it('NESTED.cbl: OUTER-PROG and INNER-PROG each have isolated paragraphs', () => {
const result = emitCobolScopeCaptures(readFixture('NESTED.cbl'), 'NESTED.cbl');
// Both programs produce separate @scope.module captures
const mods = result.filter((m) => '@scope.module' in m);
expect(mods.length).toBe(2);
// OUTER-PROG-related paragraphs
expect(findDecl(result, 'OUTER-MAIN')).toBeDefined();
expect(findDecl(result, 'OUTER-PROCESS')).toBeDefined();
// INNER-PROG-related paragraphs
expect(findDecl(result, 'INNER-MAIN')).toBeDefined();
expect(findDecl(result, 'INNER-PROCESS')).toBeDefined();
// CALL "INNER-PROG" from OUTER-PROG
expect(findRef(result, 'INNER-PROG')).toBeDefined();
});
it('CUSTUPDT.cbl: CALLs in one program do not cross-contaminate paragraphs', () => {
const result = emitCobolScopeCaptures(readFixture('CUSTUPDT.cbl'), 'CUSTUPDT.cbl');
// CUSTUPDT is a single PROGRAM-ID; all paragraphs belong to it
expect(countByName(result, '@scope.module')).toBe(1);
// Verify several distinct paragraphs exist
expect(findDecl(result, 'MAIN-PARAGRAPH')).toBeDefined();
expect(findDecl(result, 'INIT-PARAGRAPH')).toBeDefined();
expect(findDecl(result, 'PROCESS-PARAGRAPH')).toBeDefined();
expect(findDecl(result, 'READ-CUSTOMER')).toBeDefined();
expect(findDecl(result, 'UPDATE-BALANCE')).toBeDefined();
expect(findDecl(result, 'WRITE-CUSTOMER')).toBeDefined();
expect(findDecl(result, 'CLEANUP-PARAGRAPH')).toBeDefined();
});
});
// ===========================================================================
// Reviewer Check 2: COPY REPLACING capture range consistency
// ===========================================================================
describe('Reviewer Check 2: COPY REPLACING — capture ranges from transformed source', () => {
it('CUSTUPDT.cbl: COPY COPYLIB REPLACING capture range matches source line', () => {
const source = readFixture('CUSTUPDT.cbl');
const lines = source.split('\n');
const result = emitCobolScopeCaptures(source, 'CUSTUPDT.cbl');
const copyMatch = findImport(result, 'COPYLIB');
expect(copyMatch).toBeDefined();
// Find '@import.statement' within the match
const importCap = copyMatch as Record<
string,
{ name: string; range: { startLine: number }; text: string }
>;
const stmt = importCap['@import.statement'];
expect(stmt).toBeDefined();
// Range should reference a valid line in the source
const lineIdx = stmt.range.startLine - 1;
expect(lineIdx).toBeGreaterThanOrEqual(0);
expect(lineIdx).toBeLessThan(lines.length);
// The line should contain COPY...COPYLIB
expect(lines[lineIdx].toUpperCase()).toContain('COPY');
expect(lines[lineIdx].toUpperCase()).toContain('COPYLIB');
});
it('RPTGEN.cbl: COPY CUSTDAT capture range matches source line', () => {
const source = readFixture('RPTGEN.cbl');
const lines = source.split('\n');
const result = emitCobolScopeCaptures(source, 'RPTGEN.cbl');
const copyMatch = findImport(result, 'CUSTDAT');
expect(copyMatch).toBeDefined();
const importCap = copyMatch as Record<
string,
{ name: string; range: { startLine: number }; text: string }
>;
const stmt = importCap['@import.statement'];
expect(stmt).toBeDefined();
const lineIdx = stmt.range.startLine - 1;
expect(lineIdx).toBeGreaterThanOrEqual(0);
expect(lineIdx).toBeLessThan(lines.length);
expect(lines[lineIdx].toUpperCase()).toContain('COPY');
expect(lines[lineIdx].toUpperCase()).toContain('CUSTDAT');
});
});
// ===========================================================================
// Reviewer Check 3: Import ownership scope
// ===========================================================================
describe('Reviewer Check 3: importOwningScope returns Module scope for COPY', () => {
it('importOwningScope walks from paragraph to enclosing Module', async () => {
// Test the importOwningScope function directly
const { cobolImportOwningScope } =
await import('../../../src/core/ingestion/languages/cobol/interpret.js');
// Simulate an import at paragraph (Function) scope:
// the function should walk up to find the Module.
const mockTree = {
getScope: (id: string) => {
if (id === 'func:test') return { id: 'func:test', kind: 'Function' } as any;
if (id === 'mod:test') return { id: 'mod:test', kind: 'Module' } as any;
return undefined;
},
getAncestors: (_id: string) => ['mod:test'],
getParent: (_id: string) => undefined,
getChildren: (_id: string) => [],
has: (_id: string) => true,
byId: new Map(),
size: 2,
};
const paraScope = {
id: 'func:test',
kind: 'Function',
name: 'TEST-PARA',
range: { startLine: 1, startCol: 0, endLine: 2, endCol: 0 },
} as any;
const result = cobolImportOwningScope(null as any, paraScope, mockTree);
expect(result).toBe('mod:test');
});
it('importOwningScope returns innermost when already in Module scope', async () => {
const { cobolImportOwningScope } =
await import('../../../src/core/ingestion/languages/cobol/interpret.js');
const mockTree = {
getScope: () => undefined,
getAncestors: () => [],
getParent: () => undefined,
getChildren: () => [],
has: () => true,
byId: new Map(),
size: 1,
};
const modScope = {
id: 'mod:test',
kind: 'Module',
name: 'MYPROG',
range: { startLine: 1, startCol: 0, endLine: 100, endCol: 0 },
} as any;
const result = cobolImportOwningScope(null as any, modScope, mockTree);
expect(result).toBe('mod:test');
});
});
// ===========================================================================
// Reviewer Check 5: Dynamic CALL produces no CALLS edge, CodeElement annotation
// ===========================================================================
describe('Reviewer Check 5: Dynamic CALL — CALL WS-VAR captures as reference', () => {
it('CUSTUPDT.cbl: CALL WS-PROG-NAME is captured as a dynamic reference', () => {
const result = emitCobolScopeCaptures(readFixture('CUSTUPDT.cbl'), 'CUSTUPDT.cbl');
// WS-PROG-NAME should appear as a CALL reference (dynamic, no quotes)
const dynRef = findRef(result, 'WS-PROG-NAME');
expect(dynRef).toBeDefined();
// Verify it's a @reference.call, not a resolved edge
const ref = dynRef as Record<string, { name: string }>;
expect(ref['@reference.call']).toBeDefined();
});
});