From 718541a8ea21996c4bf68a1994971ef845d4d6f9 Mon Sep 17 00:00:00 2001 From: Gergo Magyar Date: Sun, 25 Oct 2026 19:32:01 +0000 Subject: [PATCH] refactor(ingestion): share callable declaration facts Reuse pure parameter and signature facts between structure and scope extraction, with tree-owned caches and read-only parameter contracts. Preserve provider-specific wrappers and consumer projections. Add characterization tests, real-worker parity checks, and reproducible performance measurements. Keep the overall indexing effect explicit. Refs #3723 --- ARCHITECTURE.md | 11 + .../bench/method-declaration-facts/README.md | 67 +++ .../bench/method-declaration-facts/RESULTS.md | 88 ++++ .../method-declaration-facts/measure.mjs | 495 ++++++++++++++++++ .../trace-parameters.mjs | 47 ++ .../method-extractors/configs/csharp.ts | 3 +- .../method-extractors/configs/dart.ts | 7 +- .../method-extractors/configs/jvm.ts | 5 +- .../method-extractors/configs/php.ts | 3 +- .../method-extractors/configs/python.ts | 3 +- .../method-extractors/configs/swift.ts | 7 +- .../configs/typescript-javascript.ts | 3 +- .../method-extractors/declaration-facts.ts | 39 ++ gitnexus/src/core/ingestion/method-types.ts | 4 +- .../unit/method-declaration-facts.test.ts | 298 +++++++++++ gitnexus/test/unit/method-props.test.ts | 4 +- 16 files changed, 1068 insertions(+), 16 deletions(-) create mode 100644 gitnexus/bench/method-declaration-facts/README.md create mode 100644 gitnexus/bench/method-declaration-facts/RESULTS.md create mode 100644 gitnexus/bench/method-declaration-facts/measure.mjs create mode 100644 gitnexus/bench/method-declaration-facts/trace-parameters.mjs create mode 100644 gitnexus/src/core/ingestion/method-extractors/declaration-facts.ts create mode 100644 gitnexus/test/unit/method-declaration-facts.test.ts diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md index 08bc2a14f4..6ec1a89973 100644 --- a/ARCHITECTURE.md +++ b/ARCHITECTURE.md @@ -349,6 +349,17 @@ accesses, value uses and inheritance edges. Register a `ScopeResolver` in `SCOPE_RESOLVERS` to participate; the old per-language migration flag and parallel call-resolution DAG were removed in RING4-1 #942. +Method extraction still supplies graph properties and overload identity; scope +extraction builds the declaration metadata used by resolution. Their repeated +node-only signature callbacks share facts through `memoizeDeclarationFact` +(`ingestion/method-extractors/declaration-facts.ts`). Each callback owns a WeakMap +from the immutable parse tree to native node IDs, so separate traversal wrappers +reuse one result without retaining old trees. Parameter facts are read-only; +providers can map syntax wrappers to the same declaration identity. Each consumer +keeps its own arity/type normalization. Owner-dependent flags and file-dependent +receiver rules remain separate. The cache stays inside parser isolates; serialized +graph/ParsedFile payloads and the persistent parse-cache format remain unchanged. + A provider can explicitly restrict its edge mode. COBOL currently uses `callable-flow-only`: its established processor retains structural CALLS/IMPORTS, and scope resolution contributes procedure-pointer calls. Registration alone is diff --git a/gitnexus/bench/method-declaration-facts/README.md b/gitnexus/bench/method-declaration-facts/README.md new file mode 100644 index 0000000000..da9a1eb126 --- /dev/null +++ b/gitnexus/bench/method-declaration-facts/README.md @@ -0,0 +1,67 @@ +# Shared callable declaration facts + +Build the pre-change revision and candidate with `npm run build` in each package, +then run from the candidate's `gitnexus/` directory: + +```sh +node bench/method-declaration-facts/measure.mjs \ + --baseline-root /path/to/baseline/gitnexus \ + --samples 3 --output /tmp/method-declaration-facts.json +``` + +Use `--candidate-root` to measure a built candidate snapshot elsewhere. Put both +runtimes and their dependencies on the same filesystem. The source corpus always +comes from the checkout containing the script, and its content hash must match +between revisions. Each pair alternates revision order and uses fresh processes. + +The harness measures three forced analysis runs per process: a cold index, warm +parse-cache replay, and a changed method signature. It uses one real parse worker, +disables FTS and embeddings, and materializes graph edges for comparison. It checks +all structural nodes and edges, excluding Community/Process nodes and their membership edges, +between revisions; warm replay must match cold output, and the edit must change +the graph. Cache hit/reparse counts accompany every measurement. + +Two corpora exercise different costs: 64 generated Java/TypeScript class files +with 40 methods each, and the first 96 tracked ingestion provider sources plus +tracked same-arity, primary-constructor, record-component, and variadic fixtures. +Each includes a small file whose signature changes. These are bounded workloads, +not a claim about every repository or language distribution. + +Pass `--providers-only` for a separate nine-file parity corpus covering all eight +migrated providers plus the changed-file probe. It includes overload declarations, +a Java record, a C# primary constructor, a Kotlin companion, Python decoration, +PHP variadics, and Swift/Dart constructors. Every provider must emit its sample +callable and a resolved call to it. This mode uses the same repeated cold, warm, +and changed-file graph comparisons; all eight grammars must be installed. + +Counters separately run real scope and MethodInfo consumers for all eight +migrated languages. They report distinct parameter arrays and declaration-node +AST accesses, with semantic output hashes. These are instrumentation runs, outside +the timed analysis. A forced-GC probe reports collection of 100 discarded trees; +it does not add GC assertions to the unit suite. +Separate parameter-only timings call the callback twice for each of 1,000 +declarations in a fresh tree, across nine trials per provider. Parsing, forced GC, +and the counter instrumentation are outside those timed regions. + +Wall time includes analysis and persistence. CPU and RSS include worker threads. +RSS sampling uses 20 ms intervals; cumulative maximum RSS is the process high-water +mark, so later scenarios may inherit an earlier peak. GC duration covers only the +main isolate. Progress-phase times use callback intervals, not exclusive CPU +profiles. Compare distributions and report noise; reduced extraction counts alone +do not establish an end-to-end speedup. + +See [the recorded results](RESULTS.md) for the initial measurements and their limits. + +To count requests and distinct parameter arrays in real workers, use the optional +preload below from the candidate package. Repeat with the candidate runtime and a +different, nonexistent output file. The preload also runs inside parser workers; +group records by thread, tree, provider, and node, and count unique `(thread, array)` +pairs. These runs are instrumented: discard their timing and memory measurements. + +```sh +FACT_RUNTIME_ROOT=/path/to/baseline/gitnexus \ +FACT_COUNTER_LOG=/tmp/baseline-parameters.jsonl \ +NODE_OPTIONS='--import=/absolute/path/to/gitnexus/bench/method-declaration-facts/trace-parameters.mjs' \ +node --expose-gc bench/method-declaration-facts/measure.mjs \ + --child analysis --root /path/to/baseline/gitnexus --corpus repository +``` diff --git a/gitnexus/bench/method-declaration-facts/RESULTS.md b/gitnexus/bench/method-declaration-facts/RESULTS.md new file mode 100644 index 0000000000..3cfa2a9f56 --- /dev/null +++ b/gitnexus/bench/method-declaration-facts/RESULTS.md @@ -0,0 +1,88 @@ +# Measurement results — 2026-10-25 + +Baseline: `ee7eff97f7f4eb7d68f7090cba448f7cc8285db2`. Candidate: this refactor before commit. The SHA-256 of sorted changed production paths and file bytes, each separated by NUL, is `b6e82236a38c3a0cbd073f2ef162885613869a32c6da9c2d906ecc85a6ff5ea6`. Both revisions were built independently and used the same installed dependencies. + +Runtime: Node v22.23.3, Linux, 12th Gen Intel(R) Core(TM) i9-12900K, one parse worker. Runtimes, dependencies, and temporary corpora were on the same native filesystem. This was a shared development host, without CPU isolation. Full tests and graph indexing were started only after these measurements. + +## Extraction work + +For all eight providers, scope and structure consumers produced identical semantic hashes. Distinct parameter arrays fell from **2 to 1**. Separate uninstrumented trials called parameter extraction twice on each of 1,000 declarations in a fresh tree; parsing and forced GC were outside the timed region. The table reports medians of nine trials per provider. These small fixtures measure extraction cost, not overall indexing. + +| Provider | Baseline wall ms | Candidate wall ms | Baseline CPU ms | Candidate CPU ms | Root AST accesses before → after | +| ---------- | ---------------: | ----------------: | --------------: | ---------------: | -------------------------------: | +| java | 32.60 | 15.46 | 60.19 | 32.73 | 63 → 62 | +| typescript | 37.75 | 19.20 | 64.63 | 36.29 | 59 → 58 | +| kotlin | 47.40 | 28.13 | 75.01 | 49.54 | 105 → 101 | +| csharp | 60.80 | 30.37 | 92.36 | 52.97 | 181 → 180 | +| python | 89.85 | 44.75 | 152.75 | 84.62 | 67 → 57 | +| php | 27.56 | 17.37 | 43.57 | 27.17 | 63 → 62 | +| swift | 85.46 | 48.28 | 98.17 | 64.23 | 269 → 246 | +| dart | 77.63 | 34.35 | 102.06 | 55.27 | 50 → 66 | + +The Dart wrapper-to-inner-declaration lookup adds root-node accesses while avoiding the second parameter traversal. Root access counts do not count descendant reads, `tree`, or `id`; they are not total AST traversal counts. Scope-specific transformations still run independently. + +A separate real-worker trace of the repository corpus, aggregated across cold, +warm, and changed-file analysis, recorded **1,391 parameter requests** in both +revisions. They produced **1,391 distinct arrays before and 784 after** (43.6% +fewer). Of 784 declarations, 607 were requested twice and 177 arrow functions were +requested once. Those single requests still incur cache bookkeeping. The observed +migrated callbacks in this corpus were TypeScript; cold analysis parsed 98 of its +142 manifest files. Graph hashes still matched. These trace runs overlapped the +test suite, so their timing and memory values are excluded from the tables below. +The optional preload in [README.md](README.md) reproduces these counters. + +## End-to-end analysis + +Three paired trials per corpus alternated revision order. Each process ran cold analysis, warm parse-cache replay, and a changed-file analysis. Wall time includes persistence. All six pairs matched structural graph hashes and node/edge counts in every scenario. Cold/warm graphs matched; changed signatures changed the graph. Cold and changed runs used real parser workers; warm runs replayed cache entries without workers. + +| Corpus | Files | Content manifest SHA-256 | +| ------------ | ----: | ------------------------------------------------------------------ | +| declarations | 65 | `a8f8aa6206812f6bdcd24fce9d89dcf25d14eaf7b1c86ba49aea1ca64f729e40` | +| repository | 142 | `ccafcd91d22aaccd886e978717499148823ca804132d64956f7f1ca9e9df1277` | + +Wall times are median [minimum–maximum], milliseconds. + +| Corpus / scenario | Baseline | Candidate | Median change | +| ---------------------- | ------------------: | ------------------: | ------------: | +| declarations / cold | 6621 [6485–7814] | 7616 [6773–8238] | +15.0% | +| declarations / warm | 2939 [2754–3693] | 3027 [2828–3125] | +3.0% | +| declarations / changed | 3565 [3564–4160] | 3721 [3343–4708] | +4.4% | +| repository / cold | 13737 [11731–15283] | 16039 [10623–18116] | +16.8% | +| repository / warm | 6829 [5838–7794] | 7580 [5162–10662] | +11.0% | +| repository / changed | 7556 [6348–7656] | 8035 [5832–9154] | +6.3% | + +Additional medians, shown baseline → candidate. RSS is the sampled peak, CPU includes workers, and GC measures only the main isolate. Parsing is a progress-callback interval rather than an exclusive profile. + +| Corpus / scenario | CPU ms | RSS MiB | Main GC ms | Parsing interval ms | +| ---------------------- | ----------------: | ------------: | ------------: | ------------------: | +| declarations / cold | 7367.8 → 8149.3 | 530.5 → 558.7 | 131.4 → 170.2 | 3286.3 → 3211.9 | +| declarations / warm | 2931.8 → 2876.1 | 636.6 → 651.3 | 195.1 → 198.4 | 175.6 → 154.4 | +| declarations / changed | 3397.3 → 3522.6 | 708.9 → 713.0 | 121.3 → 120.9 | 1008.0 → 1060.6 | +| repository / cold | 17199.8 → 20591.9 | 759.5 → 753.4 | 229.3 → 306.4 | 6954.7 → 8205.3 | +| repository / warm | 7137.5 → 7288.9 | 883.5 → 873.4 | 248.3 → 268.6 | 299.7 → 315.3 | +| repository / changed | 7698.1 → 8652.0 | 951.2 → 954.2 | 253.2 → 261.4 | 1202.5 → 1242.8 | + +The final end-to-end medians were slower. An earlier complete six-pair run, before the narrow Python/Dart wrapper identity correction, showed cold median changes of +1.7% for declarations and −4.4% for repository sources. The final run also shifted warm-cache timings, where the extraction cache is not used. These observations and the wide overlapping ranges leave the overall indexing effect unresolved; they do **not** establish a speedup or rule out a regression. Repeat on an isolated host and larger representative corpora before claiming an end-to-end gain. + +The isolated measurement does establish lower repeated parameter-extraction cost. It does not account for workload-dependent cache bookkeeping across every declaration shape. Retention remained bounded in the forced-GC probe: **100/100 discarded trees were collected in both revisions**. Post-GC main heap was 6.87 MiB before and 6.88 MiB after. Warm reparse counts were zero; changed-file runs reparsed one file. The RSS sample and small lifetime probe cannot establish a general peak-memory improvement. + +Reproduce with the command and limitations in [README.md](README.md). The harness emits per-trial JSON, including all phase intervals, CPU, GC, sampled/cumulative RSS, cache counts, corpus manifests, graph hashes, and parameter-only timings. + +## Mixed-provider worker parity + +Three additional paired runs used `--providers-only`: eight provider files plus +the changed-file probe. Every run asserted that each provider emitted its sample +callable and a resolved call to it. The fixtures include Java records, C# primary +constructors, Kotlin companions, overloads, Python decorators, PHP variadics, and +Swift/Dart constructors. Swift's existing `Function` classification is preserved. + +All pairs matched **47 structural nodes and 46 edges** in every scenario. Cold +runs parsed nine files; warm runs parsed zero; changed runs parsed one. The cold +and warm graph hash was +`131f1043fb43b9635228595748bd1a15d853b10f86ed40902303612918b15169`; +the changed graph hash was +`93734f2c8ea9ba0d8841e269467dc49cd2289be83aa18b13a8cebe871a6106ab`. +The corpus manifest was +`0a75726a1e88b189f63675a9e12476ca3d928d1a25ed4abf9648efbd0c9b339f`. +These extra runs overlapped the full test suite and provide correctness evidence; +their timing and memory measurements are excluded from the performance tables. diff --git a/gitnexus/bench/method-declaration-facts/measure.mjs b/gitnexus/bench/method-declaration-facts/measure.mjs new file mode 100644 index 0000000000..6d8fc9e322 --- /dev/null +++ b/gitnexus/bench/method-declaration-facts/measure.mjs @@ -0,0 +1,495 @@ +#!/usr/bin/env node +// Build both revisions, then pass --baseline-root /path/to/baseline/gitnexus. +import assert from 'node:assert/strict'; +import { execFileSync } from 'node:child_process'; +import { createHash } from 'node:crypto'; +import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'; +import os from 'node:os'; +import path from 'node:path'; +import { performance, PerformanceObserver } from 'node:perf_hooks'; +import { createRequire } from 'node:module'; +import { fileURLToPath, pathToFileURL } from 'node:url'; + +const here = fileURLToPath(import.meta.url); +const candidate = path.resolve(path.dirname(here), '../..'); +const args = process.argv.slice(2); +const option = (name, fallback) => (args.includes(name) ? args[args.indexOf(name) + 1] : fallback); +const root = path.resolve(option('--root', candidate)); +const load = (relative) => import(pathToFileURL(path.join(root, 'dist', relative))); +const digest = (value) => createHash('sha256').update(value).digest('hex'); +const stable = (value) => + JSON.stringify(value, (_, v) => + v && !Array.isArray(v) && typeof v === 'object' + ? Object.fromEntries( + Object.keys(v) + .sort() + .map((key) => [key, v[key]]), + ) + : v, + ); + +const providerFixtures = { + 'J.java': + 'record J(int value) { int f(int x) { return x; } String f(String x) { return x; } int call() { return f(1); } int fromValue() { return f(value); } }', + 'T.ts': + 'export class T { f(x: number): number; f(x: string): string; f(x: number | string) { return x; } call() { return this.f(1); } }', + 'K.kt': + 'class K(val value: Int) {\n fun f(x: Int): Int { return x }\n fun call(): Int { return f(value) }\n companion object { fun build(): K { return K(1) } }\n}', + 'C.cs': + 'public class C(int value) { public int f(int x) => x; public string f(string x) => x; public int Call() => f(1); public int FromValue() => f(value); }', + 'P.py': + 'class P:\n @staticmethod\n def f(x: int) -> int:\n return x\n def call(self) -> int:\n return P.f(1)\n', + 'Ph.php': + 'f(1, "a"); } }', + 'S.swift': + 'class S { init() {}\n func f(_ x: Int, y: String = "") -> Int { return x }\n func call() -> Int { return f(1) }\n}', + 'D.dart': + "class D { D(int value) {} int f(int x, [String y = '']) => x; int call() => f(1); int get value => 1; }", +}; + +async function countFacts() { + const require = createRequire(path.join(root, 'package.json')); + const Parser = require('tree-sitter'); + const { getLanguageGrammar } = await load('core/tree-sitter/parser-loader.js'); + const { createMethodExtractor } = await load('core/ingestion/method-extractors/generic.js'); + const specs = [ + [ + 'java', + 'jvm', + 'java', + 'method_declaration', + 'class C { int f(int x, String y) { return x; } }', + ], + [ + 'typescript', + 'typescript-javascript', + 'typescript', + 'method_definition', + 'class C { f(x: number, y: string): number { return x; } }', + ], + [ + 'kotlin', + 'jvm', + 'kotlin', + 'function_declaration', + 'class C {\n fun f(x: Int, y: String): Int { return x }\n}', + ], + [ + 'csharp', + 'csharp', + 'csharp', + 'method_declaration', + 'class C { int f(int x, string y) { return x; } }', + ], + [ + 'python', + 'python', + 'python', + 'function_definition', + 'class C:\n def f(self, x: int, y: str) -> int:\n return x\n', + ], + [ + 'php', + 'php', + 'php', + 'method_declaration', + ' Int { return x } }', + ], + [ + 'dart', + 'dart', + 'dart', + 'method_signature', + 'class C { int f(int x, String y) { return x; } }', + ], + ]; + const result = []; + for (const [language, module, prefix, nodeType, source] of specs) { + const grammar = getLanguageGrammar(language); + if (!grammar) { + result.push({ language, skipped: 'grammar unavailable' }); + continue; + } + const config = (await load(`core/ingestion/method-extractors/configs/${module}.js`))[ + `${prefix}MethodConfig` + ]; + const arityModule = await load(`core/ingestion/languages/${language}/arity-metadata.js`); + const arity = Object.values(arityModule).find((value) => typeof value === 'function'); + const parser = new Parser(); + parser.setLanguage(grammar); + const node = parser.parse(source).rootNode.descendantsOfType(nodeType)[0]; + let nativeReads = 0; + const counted = new Proxy(node, { + get(target, property) { + if (property !== 'tree' && property !== 'id') nativeReads++; + const value = Reflect.get(target, property, target); + return typeof value === 'function' ? value.bind(target) : value; + }, + }); + const parameterResults = new Set(); + const original = config.extractParameters; + config.extractParameters = (...values) => { + const parameters = original(...values); + parameterResults.add(parameters); + return parameters; + }; + try { + const scope = arity(counted); + const method = createMethodExtractor(config).extractFromNode(counted, { + language, + filePath: 'fixture', + }); + result.push({ + language, + nativeReads, + parameterArrays: parameterResults.size, + facts: digest(stable({ scope, method })), + }); + } finally { + config.extractParameters = original; + } + const timingSource = + language === 'php' + ? ' { + const parser = new Parser(); + parser.setLanguage(getLanguageGrammar('java')); + return Array.from({ length: 100 }, () => { + const tree = parser.parse('class C { int f(int x) { return x; } }'); + const node = tree.rootNode.descendantsOfType('method_declaration')[0]; + javaMethodConfig.extractParameters(node); + javaMethodConfig.extractParameters(node); + return new WeakRef(tree); + }); + })(); + // WeakRef targets survive the current job; collect only after yielding it. + for (let i = 0; i < 5; i++) { + await new Promise((resolve) => setImmediate(resolve)); + global.gc(); + } + return { + created: refs.length, + collected: refs.filter((ref) => ref.deref() === undefined).length, + heapAfterGcMiB: process.memoryUsage().heapUsed / 1048576, + }; +} + +async function makeCorpus(repo, corpus) { + await mkdir(repo, { recursive: true }); + await writeFile(path.join(repo, '.gitignore'), '.gitnexus/\n'); + if (corpus === 'providers') { + for (const [file, source] of Object.entries(providerFixtures)) { + await writeFile(path.join(repo, file), source + '\n'); + } + } else if (corpus === 'declarations') { + for (let file = 0; file < 32; file++) { + const ts = Array.from( + { length: 40 }, + (_, i) => `m${i}(a: number, b: string, c: Array, d = 0): number { return a + d; }`, + ).join('\n'); + const java = Array.from( + { length: 40 }, + (_, i) => `int m${i}(int a, String b, List c, int d) { return a + d; }`, + ).join('\n'); + await writeFile( + path.join(repo, `T${file}.ts`), + `export class T${file} {\n${ts}\n call() { return this.m0(1, "", [], 0); }\n}\n`, + ); + await writeFile( + path.join(repo, `J${file}.java`), + `class J${file} {\n${java}\n int call() { return m0(1, "", null, 0); }\n}\n`, + ); + } + } else { + // The same tracked source snapshot feeds both revisions. + const paths = execFileSync( + 'git', + [ + 'ls-files', + 'src/core/ingestion/method-extractors', + 'src/core/ingestion/languages', + 'test/fixtures/lang-resolution', + ], + { cwd: candidate, encoding: 'utf8' }, + ) + .trim() + .split('\n'); + const sources = paths + .filter((p) => p.startsWith('src/') && /\.ts$/.test(p)) + .sort() + .slice(0, 96); + const fixtures = paths.filter((p) => + /(?:same-arity|primary-constructor|record-component|variadic)/.test(p), + ); + for (const file of [...sources, ...fixtures]) { + await mkdir(path.dirname(path.join(repo, file)), { recursive: true }); + await cp(path.join(candidate, file), path.join(repo, file)); + } + } + await writeFile( + path.join(repo, 'change.ts'), + 'export class Changed { method(value: number): number { return value; } }\n', + ); + const git = (...values) => execFileSync('git', values, { cwd: repo, stdio: 'pipe' }); + git('init', '-q'); + git('add', '-A'); + git( + '-c', + 'user.name=benchmark', + '-c', + 'user.email=benchmark@example.invalid', + '-c', + 'commit.gpgsign=false', + 'commit', + '-qm', + 'fixture', + ); + const files = git('ls-files').toString().trim().split('\n'); + const contents = await Promise.all( + files.map(async (f) => [f, digest(await readFile(path.join(repo, f)))]), + ); + return { files: files.length - 1, manifest: digest(stable(contents)) }; +} + +function graphFacts(graph) { + const nodes = []; + graph.forEachNode((node) => { + if (!['Community', 'Process'].includes(node.label)) nodes.push(stable(node)); + }); + const edges = [...graph.relationships] + .filter((edge) => !['MEMBER_OF', 'STEP_IN_PROCESS'].includes(edge.type)) + .map(stable); + return { + nodes: nodes.length, + edges: edges.length, + hash: digest(stable([nodes.sort(), edges.sort()])), + }; +} + +async function measureAnalysis(corpus) { + const temp = await mkdtemp(path.join(os.tmpdir(), 'gitnexus-callable-facts-')); + Object.assign(process.env, { + GITNEXUS_HOME: path.join(temp, 'home'), + GITNEXUS_SHARED_STORE: 'off', + GITNEXUS_LBUG_BUFFER_POOL_SIZE: '134217728', + GITNEXUS_LBUG_EXTENSION_INSTALL: 'never', + GITNEXUS_MEMORY: 'off', + }); + const repo = path.join(temp, 'repo'); + try { + const manifest = await makeCorpus(repo, corpus); + const { runFullAnalysis } = await load('core/run-analyze.js'); + const runs = []; + for (const scenario of ['cold', 'warm', 'changed']) { + if (scenario === 'changed') + await writeFile( + path.join(repo, 'change.ts'), + 'export class Changed { method(value: string): string { return value; } }\n', + ); + global.gc?.(); + let peakRss = process.memoryUsage().rss; + let gcMs = 0; + const observer = new PerformanceObserver((list) => { + for (const entry of list.getEntries()) gcMs += entry.duration; + }); + observer.observe({ entryTypes: ['gc'] }); + const sampler = setInterval(() => { + peakRss = Math.max(peakRss, process.memoryUsage().rss); + }, 20); + const phases = {}; + let previousPhase = 'startup', + previousTime = performance.now(); + const onProgress = (phase) => { + if (phase !== previousPhase) console.error(`${scenario}: ${phase}`); + const now = performance.now(); + phases[previousPhase] = (phases[previousPhase] ?? 0) + now - previousTime; + previousPhase = phase; + previousTime = now; + }; + const cpu = process.cpuUsage(), + start = performance.now(); + let analysis; + try { + analysis = await runFullAnalysis( + repo, + { + force: true, + skipAgentsMd: true, + skipSkills: true, + skipFts: true, + streamGraphEmit: false, + workerPoolSize: 1, + }, + { onProgress, onLog: (message) => console.error(message) }, + ); + } finally { + clearInterval(sampler); + } + const wallMs = performance.now() - start, + used = process.cpuUsage(cpu); + onProgress('done'); + await new Promise((resolve) => setImmediate(resolve)); + observer.disconnect(); + const pipeline = analysis.pipelineResult; + assert(pipeline, 'analysis must return its graph'); + if (scenario !== 'warm') + assert(pipeline.usedWorkerPool, 'cache misses must use real parser workers'); + if (scenario === 'warm') assert.equal(pipeline.reparsedFileCount, 0); + if (scenario === 'changed') assert(pipeline.reparsedFileCount > 0); + if (corpus === 'providers') { + if (scenario === 'cold') { + assert.equal(pipeline.reparsedFileCount, Object.keys(providerFixtures).length + 1); + } + const methods = new Set(); + pipeline.graph.forEachNode((node) => { + if (['Method', 'Function'].includes(node.label) && node.properties.name === 'f') { + methods.add(node.properties.filePath); + } + }); + assert.deepEqual([...methods].sort(), Object.keys(providerFixtures).sort()); + const calledFiles = new Set(); + for (const edge of pipeline.graph.iterRelationshipsByType('CALLS')) { + const target = pipeline.graph.getNode(edge.targetId); + if (target?.properties.name === 'f') calledFiles.add(target.properties.filePath); + } + assert.deepEqual([...calledFiles].sort(), Object.keys(providerFixtures).sort()); + } + const facts = graphFacts(pipeline.graph); + if (scenario === 'warm') + assert.equal(facts.hash, runs[0].facts.hash, 'warm replay changed graph facts'); + if (scenario === 'changed') + assert.notEqual(facts.hash, runs[0].facts.hash, 'edited signature retained stale facts'); + runs.push({ + scenario, + wallMs, + cpuMs: (used.user + used.system) / 1000, + phases, + gcMs, + sampledPeakRssMiB: Math.max(peakRss, process.memoryUsage().rss) / 1048576, + cumulativeMaxRssMiB: process.resourceUsage().maxRSS / 1024, + reparsed: pipeline.reparsedFileCount, + hits: pipeline.parseCacheHitFileCount, + facts, + }); + } + return { manifest, runs }; + } finally { + await rm(temp, { recursive: true, force: true }); + } +} + +if (args.includes('--child')) { + const mode = option('--child'); + const result = + mode === 'counts' + ? await countFacts() + : mode === 'lifetime' + ? await retainedTrees() + : await measureAnalysis(option('--corpus')); + console.log('BENCH_RESULT=' + JSON.stringify(result)); +} else { + const baseline = option('--baseline-root'); + const candidateRuntime = path.resolve(option('--candidate-root', candidate)); + assert(baseline, 'Supply --baseline-root pointing at the built pre-change package'); + const samples = Number(option('--samples', '3')); + assert(Number.isInteger(samples) && samples >= 3, '--samples must be at least 3'); + const child = (revision, mode, corpus) => { + const output = execFileSync( + process.execPath, + ['--expose-gc', here, '--child', mode, '--root', revision, '--corpus', corpus ?? ''], + { + encoding: 'utf8', + timeout: 600_000, + maxBuffer: 32 * 1024 * 1024, + env: { ...process.env, GITNEXUS_MEMORY: 'off' }, + }, + ); + const line = output.split('\n').find((line) => line.startsWith('BENCH_RESULT=')); + assert(line, 'child did not return measurements'); + return JSON.parse(line.slice('BENCH_RESULT='.length)); + }; + const results = { + measuredAt: new Date().toISOString(), + environment: { + node: process.version, + platform: process.platform, + cpu: os.cpus()[0]?.model, + workers: 1, + }, + counts: {}, + lifetime: {}, + samples: [], + }; + for (const [name, revision] of [ + ['baseline', baseline], + ['candidate', candidateRuntime], + ]) { + results.counts[name] = child(revision, 'counts'); + results.lifetime[name] = child(revision, 'lifetime'); + } + assert.deepEqual( + results.counts.baseline.map((r) => [r.language, r.facts]), + results.counts.candidate.map((r) => [r.language, r.facts]), + ); + for (const corpus of args.includes('--providers-only') + ? ['providers'] + : ['declarations', 'repository']) { + for (let sample = 0; sample < samples; sample++) { + const pair = {}; + for (const name of sample % 2 ? ['candidate', 'baseline'] : ['baseline', 'candidate']) { + console.log(`${corpus} pair ${sample + 1}/${samples}: ${name}`); + pair[name] = child(name === 'baseline' ? baseline : candidateRuntime, 'analysis', corpus); + } + assert.deepEqual(pair.baseline.manifest, pair.candidate.manifest); + assert.deepEqual( + pair.baseline.runs.map((r) => r.facts), + pair.candidate.runs.map((r) => r.facts), + 'before/after graph facts differ', + ); + results.samples.push({ corpus, sample, ...pair }); + await writeFile( + option('--output', '/tmp/method-declaration-facts.json'), + JSON.stringify(results, null, 2) + '\n', + ); + } + } +} diff --git a/gitnexus/bench/method-declaration-facts/trace-parameters.mjs b/gitnexus/bench/method-declaration-facts/trace-parameters.mjs new file mode 100644 index 0000000000..2d62abb07e --- /dev/null +++ b/gitnexus/bench/method-declaration-facts/trace-parameters.mjs @@ -0,0 +1,47 @@ +// Optional instrumentation preload; discard timings from traced runs. +import assert from 'node:assert/strict'; +import { appendFileSync, writeFileSync } from 'node:fs'; +import { threadId } from 'node:worker_threads'; +import { pathToFileURL } from 'node:url'; +const root = process.env.FACT_RUNTIME_ROOT; +const target = process.env.FACT_COUNTER_LOG; +assert(root && target, 'Set FACT_RUNTIME_ROOT and FACT_COUNTER_LOG for this preload'); +if (threadId === 0) writeFileSync(target, '', { flag: 'wx' }); +const trees = new WeakMap(), + arrays = new WeakMap(); +let treeSerial = 0, + arraySerial = 0; +for (const [module, prefixes] of [ + ['jvm', ['java', 'kotlin']], + ['typescript-javascript', ['typescript', 'javascript']], + ['csharp', ['csharp']], + ['python', ['python']], + ['php', ['php']], + ['swift', ['swift']], + ['dart', ['dart']], +]) { + const exports = await import( + pathToFileURL(root + '/dist/core/ingestion/method-extractors/configs/' + module + '.js') + ); + for (const prefix of prefixes) { + const config = exports[prefix + 'MethodConfig']; + const original = config.extractParameters; + config.extractParameters = function (node, ...args) { + const result = original(node, ...args); + if (node.tree && !trees.has(node.tree)) trees.set(node.tree, ++treeSerial); + if (!arrays.has(result)) arrays.set(result, ++arraySerial); + appendFileSync( + target, + JSON.stringify({ + thread: threadId, + provider: prefix, + tree: trees.get(node.tree), + node: node.id, + kind: node.type, + array: arrays.get(result), + }) + '\n', + ); + return result; + }; + } +} diff --git a/gitnexus/src/core/ingestion/method-extractors/configs/csharp.ts b/gitnexus/src/core/ingestion/method-extractors/configs/csharp.ts index c6550050f3..b3a29b2557 100644 --- a/gitnexus/src/core/ingestion/method-extractors/configs/csharp.ts +++ b/gitnexus/src/core/ingestion/method-extractors/configs/csharp.ts @@ -16,6 +16,7 @@ import { collectModifierTexts, } from '../../field-extractors/configs/helpers.js'; import { extractSimpleTypeName } from '../../type-extractors/shared.js'; +import { memoizeDeclarationFact } from '../declaration-facts.js'; import type { SyntaxNode } from '../../utils/ast-helpers.js'; // --------------------------------------------------------------------------- @@ -234,7 +235,7 @@ export const csharpMethodConfig: MethodExtractionConfig = { return undefined; }, - extractParameters: extractCSharpParameters, + extractParameters: memoizeDeclarationFact(extractCSharpParameters), extractVisibility(node) { // Detect compound C# visibilities: protected internal, private protected diff --git a/gitnexus/src/core/ingestion/method-extractors/configs/dart.ts b/gitnexus/src/core/ingestion/method-extractors/configs/dart.ts index af71c24bda..6afad2fc22 100644 --- a/gitnexus/src/core/ingestion/method-extractors/configs/dart.ts +++ b/gitnexus/src/core/ingestion/method-extractors/configs/dart.ts @@ -9,6 +9,7 @@ import type { } from '../../method-types.js'; import { extractSimpleTypeName } from '../../type-extractors/shared.js'; import type { SyntaxNode } from '../../utils/ast-helpers.js'; +import { memoizeDeclarationFact } from '../declaration-facts.js'; // --------------------------------------------------------------------------- // Dart helpers @@ -415,9 +416,9 @@ export const dartMethodConfig: MethodExtractionConfig = { methodNodeTypes: ['method_signature', 'declaration'], bodyNodeTypes: ['class_body', 'extension_body'], - extractName: extractDartName, - extractReturnType: extractDartReturnType, - extractParameters: extractDartParameters, + extractName: memoizeDeclarationFact(extractDartName, getInnerSignature), + extractReturnType: memoizeDeclarationFact(extractDartReturnType, getInnerSignature), + extractParameters: memoizeDeclarationFact(extractDartParameters, getInnerSignature), extractVisibility: extractDartVisibility, isStatic: isDartStatic, diff --git a/gitnexus/src/core/ingestion/method-extractors/configs/jvm.ts b/gitnexus/src/core/ingestion/method-extractors/configs/jvm.ts index 44d65f4b37..080996f526 100644 --- a/gitnexus/src/core/ingestion/method-extractors/configs/jvm.ts +++ b/gitnexus/src/core/ingestion/method-extractors/configs/jvm.ts @@ -13,6 +13,7 @@ import { } from '../../field-extractors/configs/helpers.js'; import { extractSimpleTypeName } from '../../type-extractors/shared.js'; import type { SyntaxNode } from '../../utils/ast-helpers.js'; +import { memoizeDeclarationFact } from '../declaration-facts.js'; // --------------------------------------------------------------------------- // Shared JVM helpers @@ -131,7 +132,7 @@ export const javaMethodConfig: MethodExtractionConfig = { extractReturnType: extractReturnTypeFromField, - extractParameters: extractJavaParameters, + extractParameters: memoizeDeclarationFact(extractJavaParameters), extractVisibility(node) { return findVisibility(node, JAVA_VIS, 'package', 'modifiers'); @@ -289,7 +290,7 @@ export const kotlinMethodConfig: MethodExtractionConfig = { extractReturnType: extractKotlinReturnType, - extractParameters: extractKotlinParameters, + extractParameters: memoizeDeclarationFact(extractKotlinParameters), extractVisibility(node) { return findVisibility(node, KOTLIN_VIS, 'public', 'modifiers'); diff --git a/gitnexus/src/core/ingestion/method-extractors/configs/php.ts b/gitnexus/src/core/ingestion/method-extractors/configs/php.ts index 2d04a6bb39..69f3de29b3 100644 --- a/gitnexus/src/core/ingestion/method-extractors/configs/php.ts +++ b/gitnexus/src/core/ingestion/method-extractors/configs/php.ts @@ -9,6 +9,7 @@ import type { } from '../../method-types.js'; import { extractSimpleTypeName } from '../../type-extractors/shared.js'; import type { SyntaxNode } from '../../utils/ast-helpers.js'; +import { memoizeDeclarationFact } from '../declaration-facts.js'; // --------------------------------------------------------------------------- // PHP helpers @@ -282,7 +283,7 @@ export const phpMethodConfig: MethodExtractionConfig = { extractReturnType: extractPhpReturnType, - extractParameters: extractPhpParameters, + extractParameters: memoizeDeclarationFact(extractPhpParameters), extractVisibility: findPhpVisibility, diff --git a/gitnexus/src/core/ingestion/method-extractors/configs/python.ts b/gitnexus/src/core/ingestion/method-extractors/configs/python.ts index 0540956b1d..2a6ace0710 100644 --- a/gitnexus/src/core/ingestion/method-extractors/configs/python.ts +++ b/gitnexus/src/core/ingestion/method-extractors/configs/python.ts @@ -15,6 +15,7 @@ import { } from '../../languages/python/receiver-binding.js'; import { extractSimpleTypeName } from '../../type-extractors/shared.js'; import type { SyntaxNode } from '../../utils/ast-helpers.js'; +import { memoizeDeclarationFact } from '../declaration-facts.js'; // --------------------------------------------------------------------------- // Python helpers @@ -300,7 +301,7 @@ export const pythonMethodConfig: MethodExtractionConfig = { }, extractReturnType: extractPythonReturnType, - extractParameters: extractPythonParameters, + extractParameters: memoizeDeclarationFact(extractPythonParameters, unwrapDecorated), extractVisibility: extractPythonVisibility, isStatic(node) { diff --git a/gitnexus/src/core/ingestion/method-extractors/configs/swift.ts b/gitnexus/src/core/ingestion/method-extractors/configs/swift.ts index 1ee630b6a1..12d783ad96 100644 --- a/gitnexus/src/core/ingestion/method-extractors/configs/swift.ts +++ b/gitnexus/src/core/ingestion/method-extractors/configs/swift.ts @@ -10,6 +10,7 @@ import type { import { findVisibility, hasKeyword, hasModifier } from '../../field-extractors/configs/helpers.js'; import { extractSimpleTypeName } from '../../type-extractors/shared.js'; import type { SyntaxNode } from '../../utils/ast-helpers.js'; +import { memoizeDeclarationFact } from '../declaration-facts.js'; // --------------------------------------------------------------------------- // Swift helpers @@ -282,9 +283,9 @@ export const swiftMethodConfig: MethodExtractionConfig = { // dev-mode "body field type not in bodyNodeTypes" warning. bodyNodeTypes: ['class_body', 'protocol_body', 'enum_class_body'], - extractName: extractSwiftName, - extractReturnType: extractSwiftReturnType, - extractParameters: extractSwiftParameters, + extractName: memoizeDeclarationFact(extractSwiftName), + extractReturnType: memoizeDeclarationFact(extractSwiftReturnType), + extractParameters: memoizeDeclarationFact(extractSwiftParameters), extractVisibility(node) { return findVisibility(node, SWIFT_VIS, 'internal', 'modifiers'); diff --git a/gitnexus/src/core/ingestion/method-extractors/configs/typescript-javascript.ts b/gitnexus/src/core/ingestion/method-extractors/configs/typescript-javascript.ts index 80bd912691..2b768937b9 100644 --- a/gitnexus/src/core/ingestion/method-extractors/configs/typescript-javascript.ts +++ b/gitnexus/src/core/ingestion/method-extractors/configs/typescript-javascript.ts @@ -10,6 +10,7 @@ import type { import { hasKeyword } from '../../field-extractors/configs/helpers.js'; import { extractSimpleTypeName } from '../../type-extractors/shared.js'; import type { SyntaxNode } from '../../utils/ast-helpers.js'; +import { memoizeDeclarationFact } from '../declaration-facts.js'; // --------------------------------------------------------------------------- // TS/JS helpers @@ -309,7 +310,7 @@ const shared: Omit = { }, extractReturnType: extractTsJsReturnType, - extractParameters: extractTsJsParameters, + extractParameters: memoizeDeclarationFact(extractTsJsParameters), extractVisibility: extractTsJsVisibility, isStatic(node) { diff --git a/gitnexus/src/core/ingestion/method-extractors/declaration-facts.ts b/gitnexus/src/core/ingestion/method-extractors/declaration-facts.ts new file mode 100644 index 0000000000..26b2badfa3 --- /dev/null +++ b/gitnexus/src/core/ingestion/method-extractors/declaration-facts.ts @@ -0,0 +1,39 @@ +import type { ParameterInfo } from '../method-types.js'; +import type { SyntaxNode } from '../utils/ast-helpers.js'; + +type DeclarationFact = string | undefined | readonly Readonly[]; + +/** Share a pure, node-only fact across structure and scope extraction. + * Trees are immutable during ingestion. Native node IDs survive different JS + * wrappers; tree ownership keeps IDs from colliding across files or reparses. + * Values must contain no AST nodes. File/owner-dependent callbacks stay uncached. + * Providers may identify an equivalent declaration inside the same tree when + * one consumer sees a syntax wrapper and another sees its inner declaration. + */ +export function memoizeDeclarationFact( + extract: (node: SyntaxNode) => T, + declaration?: (node: SyntaxNode) => SyntaxNode | null, +): (node: SyntaxNode) => T { + const trees = new WeakMap>(); + return (node) => { + const tree = node.tree; + const id = node.id; + if (!tree || typeof id !== 'number') return extract(node); + let facts = trees.get(tree); + if (facts?.has(id)) return facts.get(id)!; + const declarationId = declaration?.(node)?.id ?? id; + if (declarationId !== id && facts?.has(declarationId)) { + const fact = facts.get(declarationId)!; + facts.set(id, fact); + return fact; + } + const fact = extract(node); + if (!facts) { + facts = new Map(); + trees.set(tree, facts); + } + facts.set(id, fact); + if (declarationId !== id) facts.set(declarationId, fact); + return fact; + }; +} diff --git a/gitnexus/src/core/ingestion/method-types.ts b/gitnexus/src/core/ingestion/method-types.ts index fb7c61f1f9..3e9edf2e9f 100644 --- a/gitnexus/src/core/ingestion/method-types.ts +++ b/gitnexus/src/core/ingestion/method-types.ts @@ -23,7 +23,7 @@ export interface MethodInfo { name: string; receiverType: string | null; returnType: string | null; - parameters: ParameterInfo[]; + parameters: readonly Readonly[]; visibility: MethodVisibility; isStatic: boolean; isAbstract: boolean; @@ -100,7 +100,7 @@ export interface MethodExtractionConfig { * name is the file stem, so `fn incr(counter: *Counter)` in `Counter.zig` * is a method only when the file is known. Same optional-trailing-argument * shape as `extractOwnerName`; every other config ignores it. */ - extractParameters: (node: SyntaxNode, filePath?: string) => ParameterInfo[]; + extractParameters: (node: SyntaxNode, filePath?: string) => readonly Readonly[]; extractVisibility: (node: SyntaxNode) => MethodVisibility; isStatic: (node: SyntaxNode, filePath?: string) => boolean; isAbstract: (node: SyntaxNode, ownerNode: SyntaxNode) => boolean; diff --git a/gitnexus/test/unit/method-declaration-facts.test.ts b/gitnexus/test/unit/method-declaration-facts.test.ts new file mode 100644 index 0000000000..e0556efc6a --- /dev/null +++ b/gitnexus/test/unit/method-declaration-facts.test.ts @@ -0,0 +1,298 @@ +import { describe, expect, it, vi } from 'vitest'; +import Parser from 'tree-sitter'; +import Java from 'tree-sitter-java'; +import TypeScript from 'tree-sitter-typescript'; +import { createMethodExtractor } from '../../src/core/ingestion/method-extractors/generic.js'; +import { + javaMethodConfig, + kotlinMethodConfig, +} from '../../src/core/ingestion/method-extractors/configs/jvm.js'; +import { + typescriptMethodConfig, + javascriptMethodConfig, +} from '../../src/core/ingestion/method-extractors/configs/typescript-javascript.js'; +import { csharpMethodConfig } from '../../src/core/ingestion/method-extractors/configs/csharp.js'; +import { pythonMethodConfig } from '../../src/core/ingestion/method-extractors/configs/python.js'; +import { phpMethodConfig } from '../../src/core/ingestion/method-extractors/configs/php.js'; +import { swiftMethodConfig } from '../../src/core/ingestion/method-extractors/configs/swift.js'; +import { dartMethodConfig } from '../../src/core/ingestion/method-extractors/configs/dart.js'; +import { computeJavaArityMetadata } from '../../src/core/ingestion/languages/java/arity-metadata.js'; +import { computeTsArityMetadata } from '../../src/core/ingestion/languages/typescript/arity-metadata.js'; +import { memoizeDeclarationFact } from '../../src/core/ingestion/method-extractors/declaration-facts.js'; +import { computeKotlinArityMetadata } from '../../src/core/ingestion/languages/kotlin/arity-metadata.js'; +import { computeCsharpArityMetadata } from '../../src/core/ingestion/languages/csharp/arity-metadata.js'; +import { computePythonArityMetadata } from '../../src/core/ingestion/languages/python/arity-metadata.js'; +import { computePhpArityMetadata } from '../../src/core/ingestion/languages/php/arity-metadata.js'; +import { computeSwiftArityMetadata } from '../../src/core/ingestion/languages/swift/arity-metadata.js'; +import { computeDartArityMetadata } from '../../src/core/ingestion/languages/dart/arity-metadata.js'; +import { + getLanguageGrammar, + isLanguageAvailable, +} from '../../src/core/tree-sitter/parser-loader.js'; +import { synthesizeSwiftSignatureBindings } from '../../src/core/ingestion/languages/swift/signature-bindings.js'; +import { synthesizeDartSignatureBindings } from '../../src/core/ingestion/languages/dart/signature-bindings.js'; + +describe('shared callable declaration facts', () => { + for (const fixture of [ + { + config: pythonMethodConfig, + code: 'class C:\n @staticmethod\n def f(x: int) -> int:\n return x\n', + owner: 'class_definition', + declaration: 'function_definition', + arity: computePythonArityMetadata, + }, + { + config: dartMethodConfig, + code: 'class C { C(int x) {} }', + owner: 'class_definition', + declaration: 'constructor_signature', + arity: computeDartArityMetadata, + }, + ]) { + for (const scopeFirst of [true, false]) { + it.skipIf(!isLanguageAvailable(fixture.config.language))( + `${fixture.config.language}: shares facts across declaration wrappers, scopeFirst=${scopeFirst}`, + () => { + const parser = new Parser(); + parser.setLanguage(getLanguageGrammar(fixture.config.language)!); + const tree = parser.parse(fixture.code); + expect(tree.rootNode.hasError).toBe(false); + const owner = tree.rootNode.descendantsOfType(fixture.owner)[0]!; + const declaration = owner.descendantsOfType(fixture.declaration)[0]!; + const spy = vi.spyOn(fixture.config, 'extractParameters'); + try { + if (scopeFirst) fixture.arity(declaration); + const result = createMethodExtractor(fixture.config).extract(owner, { + language: fixture.config.language, + filePath: 'fixture', + })!; + if (!scopeFirst) fixture.arity(declaration); + expect(result.methods).toHaveLength(1); + expect(result.methods[0]!.parameters.map((p) => p.type)).toEqual(['int']); + expect(spy).toHaveBeenCalledTimes(2); + expect(spy.mock.results[0]!.value).toBe(spy.mock.results[1]!.value); + } finally { + spy.mockRestore(); + } + }, + ); + } + } + for (const fixture of [ + { + language: Java, + config: javaMethodConfig, + code: 'class C { int f(int x, String... rest) { return x; } }', + nodeType: 'method_declaration', + arity: computeJavaArityMetadata, + expectedTypes: ['int', 'String'], + }, + { + language: TypeScript.typescript, + config: typescriptMethodConfig, + code: 'class C { f(x: number, ...rest: string[]): number { return x; } }', + nodeType: 'method_definition', + arity: computeTsArityMetadata, + expectedTypes: ['number', 'string[]'], + }, + ]) { + for (const scopeFirst of [true, false]) { + it(`${fixture.config.language}: traverses parameters once, scopeFirst=${scopeFirst}`, () => { + const parser = new Parser(); + parser.setLanguage(fixture.language); + const tree = parser.parse(fixture.code); + const node = tree.rootNode.descendantsOfType(fixture.nodeType)[0]!; + const read = vi.spyOn(node, 'childForFieldName'); + const extractor = createMethodExtractor(fixture.config); + const structure = () => + extractor.extractFromNode!(node, { + filePath: 'fixture', + language: fixture.config.language, + }); + if (scopeFirst) fixture.arity(node); + const info = structure()!; + if (!scopeFirst) fixture.arity(node); + expect(info.name).toBe('f'); + expect(info.parameters.map((p) => p.rawType ?? p.type)).toEqual(fixture.expectedTypes); + expect(info.parameters.map((p) => p.isVariadic)).toEqual([false, true]); + // Count the native parameter-list access, not calls to the config wrapper. + expect(read.mock.calls.filter(([field]) => field === 'parameters')).toHaveLength(1); + read.mockRestore(); + }); + } + } + + for (const fixture of [ + { + config: kotlinMethodConfig, + code: 'class C {\n fun f(x: Int, y: String): Int { return x }\n}', + nodeType: 'function_declaration', + arity: computeKotlinArityMetadata, + types: ['Int', 'String'], + }, + { + config: csharpMethodConfig, + code: 'class C { public int F(int x, string y = "") { return x; } }', + nodeType: 'method_declaration', + arity: computeCsharpArityMetadata, + types: ['int', 'string'], + }, + { + config: pythonMethodConfig, + code: 'class C:\n def f(self, x: int, y: str = "") -> int:\n return x\n', + nodeType: 'function_definition', + arity: computePythonArityMetadata, + types: ['int', 'str'], + }, + { + config: phpMethodConfig, + code: ' Int { return x } }', + nodeType: 'function_declaration', + arity: computeSwiftArityMetadata, + types: ['Int', 'String'], + }, + { + config: dartMethodConfig, + code: "class C { int f(int x, [String y = '']) { return x; } }", + nodeType: 'method_signature', + arity: computeDartArityMetadata, + types: ['int', 'String'], + }, + ]) { + it.skipIf(!isLanguageAvailable(fixture.config.language))( + `${fixture.config.language}: scope and structure reuse parameter facts`, + () => { + const parser = new Parser(); + parser.setLanguage(getLanguageGrammar(fixture.config.language)!); + const tree = parser.parse(fixture.code); + expect(tree.rootNode.hasError).toBe(false); + const node = tree.rootNode.descendantsOfType(fixture.nodeType)[0]!; + const spy = vi.spyOn(fixture.config, 'extractParameters'); + try { + const scope = fixture.arity(node); + const info = createMethodExtractor(fixture.config).extractFromNode!(node, { + language: fixture.config.language, + filePath: 'fixture', + })!; + expect(info.parameters.map((p) => p.type)).toEqual(fixture.types); + expect(scope.parameterTypes?.slice(0, 2)).toEqual(fixture.types); + expect(spy).toHaveBeenCalledTimes(2); + // Both real consumers must receive the same facts, including through config copies. + expect(info.parameters).toBe(spy.mock.results[0]!.value); + } finally { + spy.mockRestore(); + } + }, + ); + } + + it('shares the parameter callback through the JavaScript config copy', () => { + const parser = new Parser(); + parser.setLanguage(getLanguageGrammar(javascriptMethodConfig.language)!); + const node = parser + .parse('class C { f(x, ...rest) {} }') + .rootNode.descendantsOfType('method_definition')[0]!; + expect(javascriptMethodConfig.extractParameters).toBe(typescriptMethodConfig.extractParameters); + expect(javascriptMethodConfig.extractParameters(node)).toBe( + typescriptMethodConfig.extractParameters(node), + ); + }); + + for (const fixture of [ + { + config: swiftMethodConfig, + code: 'class C { func f(_ x: Int) -> Int { return x } }', + nodeType: 'function_declaration', + bindings: synthesizeSwiftSignatureBindings, + }, + { + config: dartMethodConfig, + code: 'class C { int f(int x) { return x; } }', + nodeType: 'method_signature', + bindings: (node: Parser.SyntaxNode) => + synthesizeDartSignatureBindings(node, node.nextNamedSibling), + }, + ]) { + it.skipIf(!isLanguageAvailable(fixture.config.language))( + `${fixture.config.language}: signature bindings share name and return facts`, + () => { + const parser = new Parser(); + parser.setLanguage(getLanguageGrammar(fixture.config.language)!); + const node = parser.parse(fixture.code).rootNode.descendantsOfType(fixture.nodeType)[0]!; + let reads = 0; + const counted = new Proxy(node, { + get(target, property) { + if (property !== 'tree' && property !== 'id') reads++; + const value = Reflect.get(target, property, target); + return typeof value === 'function' ? value.bind(target) : value; + }, + }); + expect(fixture.bindings(counted).length).toBeGreaterThan(0); + const before = reads; + expect(before).toBeGreaterThan(0); + expect(fixture.config.extractName(counted)).toBe('f'); + expect(fixture.config.extractReturnType(counted)).toMatch(/^[Ii]nt$/); + expect(reads).toBe(before); + }, + ); + } + + it('separates same-line declarations and reparsed trees', () => { + const parser = new Parser(); + parser.setLanguage(Java); + const first = parser.parse('class C { void f(int x) {} void f(String s) {} }'); + const second = parser.parse('class C { void f(long x) {} }'); + const [intNode, stringNode] = first.rootNode.descendantsOfType('method_declaration'); + const longNode = second.rootNode.descendantsOfType('method_declaration')[0]!; + expect(javaMethodConfig.extractParameters(intNode!)[0]!.type).toBe('int'); + expect(javaMethodConfig.extractParameters(stringNode!)[0]!.type).toBe('String'); + expect(javaMethodConfig.extractParameters(longNode)[0]!.type).toBe('long'); + }); + + it('reuses empty and absent facts across wrappers with the same native identity', () => { + const parser = new Parser(); + parser.setLanguage(Java); + const tree = parser.parse('class C { void f() {} }'); + const node = tree.rootNode.descendantsOfType('method_declaration')[0]!; + // A fresh traversal may already reuse a JS wrapper. This wrapper deliberately + // differs while preserving the actual native tree/node identity. + const wrapper = new Proxy(node, {}); + expect(wrapper).not.toBe(node); + const absent = vi.fn(() => undefined); + const empty = vi.fn(() => []); + for (const extract of [absent, empty]) { + const shared = memoizeDeclarationFact(extract); + const first = shared(node); + expect(shared(wrapper)).toBe(first); + expect(extract).toHaveBeenCalledTimes(1); + } + }); + + it('retries failures and bypasses sharing when tree identity is unavailable', () => { + const parser = new Parser(); + parser.setLanguage(Java); + const node = parser.parse('class C {}').rootNode; + const extract = vi + .fn<() => string>() + .mockImplementationOnce(() => { + throw new Error('incomplete'); + }) + .mockReturnValue('complete'); + const shared = memoizeDeclarationFact(extract); + expect(() => shared(node)).toThrow('incomplete'); + expect(shared(node)).toBe('complete'); + expect(shared(node)).toBe('complete'); + expect(extract).toHaveBeenCalledTimes(2); + const partial = {} as Parser.SyntaxNode; + shared(partial); + shared(partial); + expect(extract).toHaveBeenCalledTimes(4); + }); +}); diff --git a/gitnexus/test/unit/method-props.test.ts b/gitnexus/test/unit/method-props.test.ts index cd1be05e00..468580ff07 100644 --- a/gitnexus/test/unit/method-props.test.ts +++ b/gitnexus/test/unit/method-props.test.ts @@ -119,7 +119,7 @@ describe('typeTagForId', () => { it('returns empty string for variadic method (arity undefined)', () => { const m = makeMethodInfo('log', [{ name: 'args', type: 'String' }]); - m.parameters[0].isVariadic = true; + m.parameters = m.parameters.map((parameter) => ({ ...parameter, isVariadic: true })); const map = buildMethodMap([m]); expect(typeTagForId(map, 'log', undefined, m)).toBe(''); @@ -204,7 +204,7 @@ describe('arityForIdFromInfo', () => { it('returns undefined for variadic methods', () => { const m = makeMethodInfo('log', [{ name: 'args', type: 'String' }]); - m.parameters[0].isVariadic = true; + m.parameters = m.parameters.map((parameter) => ({ ...parameter, isVariadic: true })); expect(arityForIdFromInfo(m)).toBeUndefined(); });