mirror of
https://github.com/colbymchenry/codegraph.git
synced 2026-10-18 13:53:01 +08:00
Colby Mchenry
3f714bcc48
Value-reference edges (a reader symbol -> the file-scope const/var it reads, which impact follows) ran for typescript, tsx and javascript but not jsx. A .jsx file is its own language, parsed with the JavaScript grammar, so the same component had no edge to the lazy page it renders (`<LoginPage />` under `const LoginPage = Loadable(lazy(...))`), the route table or the config it maps over as .jsx, and all of them as .js or .tsx. Every other JS-family gate in the extractor lists jsx, and nothing in the history says this one was left out on purpose: the kernel mirrored the gap with an explicit "NOT jsx" check for parity. Add jsx to VALUE_REF_LANGS and drop the kernel's jsx exclusion. On mantis, matx, berry, mastodon and bigbluebutton-html5 the index only gains edges (35, 56, 15, 28 and 266): no node, ref or file changes and no edge removed. Every added edge is a same-file read of a file-scope value that is the only binding of its name in the file. A repo with no .jsx files indexes byte-identically, and kernel-parity.mjs shows 0 diffs over those repos with the same deferrals as before. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
507 lines
23 KiB
TypeScript
507 lines
23 KiB
TypeScript
/**
|
|
* Kernel↔wasm TS/JS extraction parity (R2 of the kernel migration).
|
|
*
|
|
* Asserts the native walker (codegraph-kernel/src/tsjs/) produces the SAME
|
|
* ExtractionResult as the wasm TreeSitterExtractor — nodes, edges, and
|
|
* unresolved refs compared as canonicalized multisets — over:
|
|
* - the checked-in torture fixtures (every ported feature: components/HOCs,
|
|
* stores, RTK, vuex, fn-refs, value-ref shadowing, decorators, enums,
|
|
* type-alias members/tuple contracts, re-exports, JSX, field methods), and
|
|
* - this repo's own extraction sources (real-world TS).
|
|
*
|
|
* The full-repo sweep lives in scripts/kernel-parity.mjs (excalidraw et al.,
|
|
* run for the §5 gate); this suite keeps the invariant alive in `npm test`.
|
|
* Skips when no kernel binary is staged; CODEGRAPH_KERNEL_EXPECT=1 turns that
|
|
* into a failure (wired in kernel-scaffold.test.ts).
|
|
*/
|
|
|
|
import { describe, it, expect, beforeAll, beforeEach, afterEach } from 'vitest';
|
|
import * as fs from 'fs';
|
|
import * as path from 'path';
|
|
import { extractFromSource } from '../src/extraction';
|
|
import { initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars';
|
|
import { tryKernelExtract, resetKernelForTests } from '../src/extraction/kernel';
|
|
import type { ExtractionResult, Language } from '../src/types';
|
|
|
|
const KERNEL_PATH = path.join(
|
|
__dirname,
|
|
'..',
|
|
'codegraph-kernel',
|
|
'prebuilds',
|
|
`${process.platform}-${process.arch}`,
|
|
'codegraph-kernel.node'
|
|
);
|
|
const kernelBuilt = fs.existsSync(KERNEL_PATH);
|
|
|
|
const FIXTURE_DIR = path.join(__dirname, 'fixtures', 'kernel-parity');
|
|
const REAL_SOURCES = [
|
|
'src/extraction/kernel/loader.ts',
|
|
'src/extraction/kernel/decode.ts',
|
|
'src/extraction/parse-pool.ts',
|
|
'src/extraction/function-ref.ts',
|
|
'src/mcp/tools.ts',
|
|
];
|
|
|
|
function canon(result: ExtractionResult): { nodes: string[]; edges: string[]; refs: string[] } {
|
|
return {
|
|
nodes: result.nodes
|
|
.map(({ updatedAt: _u, ...n }) => JSON.stringify(n, Object.keys(n).sort()))
|
|
.sort(),
|
|
edges: result.edges.map((e) => JSON.stringify(e, Object.keys(e).sort())).sort(),
|
|
refs: result.unresolvedReferences
|
|
.map((r) => JSON.stringify(r, Object.keys(r).sort()))
|
|
.sort(),
|
|
};
|
|
}
|
|
|
|
const ENV_KEYS = ['CODEGRAPH_KERNEL', 'CODEGRAPH_KERNEL_LANGS'] as const;
|
|
let savedEnv: Record<string, string | undefined>;
|
|
|
|
describe.skipIf(!kernelBuilt)('kernel TS/JS extraction parity', () => {
|
|
beforeAll(async () => {
|
|
await initGrammars();
|
|
await loadGrammarsForLanguages(['typescript', 'tsx', 'javascript', 'jsx', 'java', 'python', 'go']);
|
|
});
|
|
|
|
beforeEach(() => {
|
|
savedEnv = Object.fromEntries(ENV_KEYS.map((k) => [k, process.env[k]]));
|
|
resetKernelForTests();
|
|
});
|
|
|
|
afterEach(() => {
|
|
for (const k of ENV_KEYS) {
|
|
if (savedEnv[k] === undefined) delete process.env[k];
|
|
else process.env[k] = savedEnv[k];
|
|
}
|
|
resetKernelForTests();
|
|
});
|
|
|
|
function assertParity(filePath: string, source: string, language: Language): ExtractionResult {
|
|
process.env.CODEGRAPH_KERNEL_LANGS = 'all';
|
|
delete process.env.CODEGRAPH_KERNEL;
|
|
const viaKernel = tryKernelExtract(filePath, source, language);
|
|
expect(viaKernel, `kernel extraction failed for ${filePath}`).not.toBeNull();
|
|
|
|
process.env.CODEGRAPH_KERNEL = '0';
|
|
const viaWasm = extractFromSource(filePath, source, language);
|
|
delete process.env.CODEGRAPH_KERNEL;
|
|
|
|
const k = canon(viaKernel!);
|
|
const w = canon(viaWasm);
|
|
expect(k.nodes, `${filePath}: nodes`).toEqual(w.nodes);
|
|
expect(k.edges, `${filePath}: edges`).toEqual(w.edges);
|
|
expect(k.refs, `${filePath}: refs`).toEqual(w.refs);
|
|
// Meaningful comparison, not empty-vs-empty.
|
|
expect(viaWasm.nodes.length).toBeGreaterThan(3);
|
|
return viaWasm;
|
|
}
|
|
|
|
it.each([
|
|
['ts', 'typescript'], ['tsx', 'tsx'], ['js', 'javascript'], ['jsx', 'jsx'],
|
|
] as const)('named object literals own their members: %s (#2300)', (ext, language) => {
|
|
const source = [
|
|
'/* é😀 */ const Api = { read() { helper(); }, close: () => helper(), gen: function* () { yield 1; }, \'quoted-key\': function () {}, [dyn()]() { helper(); }, eager: helper(), alias: helper, helper };',
|
|
'function helper() {}',
|
|
'/** Saved. */',
|
|
'export const Exported = { save() { helper(); } };',
|
|
'(function () { const Local = { run() { helper(); } }, data = { x: 1 }; Local.run(); window.WS = { ws() { Local.run(); } }; })();',
|
|
'App.utils = { pad(s) { return s; } };',
|
|
'// The page.',
|
|
'dw_page = { start() { helper(); } };',
|
|
'function setup() { ns.late = { go() {} }; let h; h = { on() {} }; }',
|
|
'module.exports = { cjs() {} };',
|
|
'Foo.prototype = { proto() {} };',
|
|
'self.handlers = { click() {} };',
|
|
'consume({ ephemeral() {} });',
|
|
'',
|
|
].join('\n');
|
|
for (const ending of ['\n', '\r\n']) {
|
|
const result = assertParity(`literal.${ext}`, source.replace(/\n/g, ending), language);
|
|
expect(result.nodes.map((n) => n.qualifiedName)).toEqual(expect.arrayContaining([
|
|
'Api::read', 'Api::close', 'Api::gen', 'Api::quoted-key', 'Exported::save', 'Local::run', 'window.WS',
|
|
'window.WS::ws', 'App.utils::pad', 'dw_page::start', 'ns.late::go', 'self.handlers::click',
|
|
]));
|
|
// A plain name reassigned inside a function is a local, not a namespace.
|
|
for (const name of ['cjs', 'proto', 'ephemeral', 'data', 'on']) expect(result.nodes.some((n) => n.name === name), name).toBe(false);
|
|
}
|
|
});
|
|
|
|
it.each(['bundle.js', 'vendor-min.js', 'vendor.min.js'])('a minified bundle keeps its literals unowned: %s (#2300)', (file) => {
|
|
// Mostly long lines dense with code punctuation, as a minifier writes them.
|
|
const line = `var a={b:function(){return c(1,2)},d:function(e){return e}};window.L={f:function(){return a.b()}};`.repeat(40);
|
|
const result = assertParity(file, `${line}\n${line}\n`, 'javascript');
|
|
expect(result.nodes.some((n) => n.kind === 'function' && (n.name === 'b' || n.name === 'f'))).toBe(false);
|
|
});
|
|
|
|
describe.each([
|
|
['ts', 'typescript'], ['tsx', 'tsx'], ['js', 'javascript'], ['jsx', 'jsx'],
|
|
] as const)('a store exported by a later statement: %s', (ext, language) => {
|
|
it.each(['LF', 'CRLF'])('keeps its actions (%s)', (ending) => {
|
|
// `export default useStore;` is found by a multiline regex over the
|
|
// source. JS's `$` matches before the `\r` of a CRLF line ending; the
|
|
// kernel's must too, or a Windows checkout loses the store's actions.
|
|
const source = [
|
|
'import { create } from "zustand";',
|
|
'const useStore = create((set) => ({ inc: () => set({}) }));',
|
|
'export default useStore;',
|
|
'',
|
|
].join(ending === 'CRLF' ? '\r\n' : '\n');
|
|
const result = assertParity(`store.${ext}`, source, language);
|
|
expect(result.nodes.some((n) => n.kind === 'function' && n.name === 'inc')).toBe(true);
|
|
});
|
|
|
|
it.each([
|
|
['items$', 'export { items$ };', true],
|
|
['$items', 'export { $items as default };', true],
|
|
['items', 'export { items$ };', false],
|
|
['items', 'export { $items };', false],
|
|
] as const)('an export clause names %s only whole: `%s`', (name, exportLine, kept) => {
|
|
// `\b` takes a `$` for a separator: it can't bound `items$` or
|
|
// `$items`, and it finds `items` inside both. `other` keeps the
|
|
// negative cases above assertParity's node floor.
|
|
const source = [
|
|
'import { create } from "zustand";',
|
|
`const ${name} = create((set) => ({ inc: () => set({}) }));`,
|
|
'const other = 1;',
|
|
exportLine,
|
|
'',
|
|
].join('\n');
|
|
const result = assertParity(`store.${ext}`, source, language);
|
|
expect(result.nodes.some((n) => n.kind === 'function' && n.name === 'inc')).toBe(kept);
|
|
});
|
|
});
|
|
|
|
describe.each([
|
|
['ts', 'typescript'], ['tsx', 'tsx'], ['js', 'javascript'], ['jsx', 'jsx'],
|
|
] as const)('a store whose name has a `$`, exported by a later statement: %s', (ext, language) => {
|
|
// The later-export check builds a regex from the name. Its `$` must match
|
|
// the character, as the kernel's escaped pattern does, not a line end.
|
|
const store = (name: string, ...exportLines: string[]) => [
|
|
'import { create } from "zustand";',
|
|
`const ${name} = create((set) => ({ inc: () => set({}) }));`,
|
|
...exportLines,
|
|
'',
|
|
].join('\n');
|
|
|
|
it.each([
|
|
['items$', 'export default items$;'],
|
|
['$store', 'export default $store;'],
|
|
['a$b', 'export { a$b };'],
|
|
])('keeps its actions (%s)', (name, exportLine) => {
|
|
const result = assertParity(`store.${ext}`, store(name, exportLine), language);
|
|
expect(result.nodes.some((n) => n.kind === 'function' && n.name === 'inc')).toBe(true);
|
|
});
|
|
|
|
it('is not exported by a different name at a line end', () => {
|
|
const result = assertParity(`store.${ext}`, store('items$', 'const items = 1;', 'export {', ' items', '};'), language);
|
|
expect(result.nodes.some((n) => n.kind === 'function' && n.name === 'inc')).toBe(false);
|
|
});
|
|
});
|
|
|
|
it.each([
|
|
['ts', 'typescript'], ['tsx', 'tsx'], ['js', 'javascript'], ['jsx', 'jsx'],
|
|
] as const)('same-line accessors retain distinct identities after Unicode: %s (#1349)', (ext, language) => {
|
|
const source = 'class Point { /* é😀 */ get x() { return read(); } set x(v) { write(v); } }';
|
|
const result = assertParity(`point.${ext}`, source, language);
|
|
const x = result.nodes.filter((n) => n.name === 'x');
|
|
expect(x).toHaveLength(2);
|
|
expect(x[1]!.id).toBe(`${x[0]!.id}:${source.indexOf('set x')}`);
|
|
expect(result.unresolvedReferences.filter((r) => r.referenceKind === 'calls').map((r) => [r.fromNodeId, r.referenceName]))
|
|
.toEqual([[x[0]!.id, 'read'], [x[1]!.id, 'write']]);
|
|
// No state leaks between files or repeated extractions.
|
|
expect(canon(assertParity(`point.${ext}`, source, language))).toEqual(canon(result));
|
|
});
|
|
|
|
it.each([
|
|
['ts', 'typescript'], ['tsx', 'tsx'], ['js', 'javascript'], ['jsx', 'jsx'],
|
|
] as const)('leaves nested identifier receivers unresolved and keeps argument calls: %s (#1566)', (ext, language) => {
|
|
const result = assertParity(`fixture.${ext}`, `
|
|
function readKey() { return 'answer'; }
|
|
function local() {
|
|
const values = new Map();
|
|
return values.get(readKey());
|
|
}
|
|
function nested(holder) {
|
|
holder.values.get(readKey());
|
|
holder.values?.get(readKey());
|
|
holder['values'].get(readKey());
|
|
holder.deep.values.get(readKey());
|
|
}
|
|
`, language);
|
|
const nested = result.nodes.find((n) => n.name === 'nested' && n.kind === 'function');
|
|
expect(nested).toBeDefined();
|
|
expect(result.unresolvedReferences.filter((r) => r.referenceKind === 'calls' && r.fromNodeId === nested!.id)
|
|
// Qualified sites are retained for effects; computed keys still make no
|
|
// receiver claim. All four calls inside arguments must also survive.
|
|
.map((r) => r.referenceName)).toEqual([
|
|
'holder.values.get', 'readKey', 'holder.values.get', 'readKey',
|
|
'readKey', 'holder.deep.values.get', 'readKey',
|
|
]);
|
|
expect(result.unresolvedReferences.some((r) => r.referenceName === 'values.get')).toBe(true);
|
|
});
|
|
|
|
describe.each([
|
|
['ts', 'typescript'], ['tsx', 'tsx'], ['js', 'javascript'], ['jsx', 'jsx'],
|
|
] as const)('private field receivers: %s (#1987)', (ext, language) => {
|
|
it.each(['LF', 'CRLF'])('preserves private fields and optional calls (%s)', (ending) => {
|
|
const source = `
|
|
class Mailer { send() {} }
|
|
class Vault {
|
|
#mailer = new Mailer();
|
|
#items = new Set();
|
|
notify() { this.#mailer?.send(); }
|
|
optional() { this.#mailer.send?.(); }
|
|
put() { this.#items?.add('x'); }
|
|
}
|
|
`;
|
|
const result = assertParity(`vault.${ext}`, ending === 'CRLF' ? source.replace(/\n/g, '\r\n') : source, language);
|
|
expect(result.unresolvedReferences.filter(r => r.referenceKind === 'calls').map(r => r.referenceName))
|
|
.toEqual(['this.#mailer.send', 'this.#mailer.send', 'this.#items.add']);
|
|
});
|
|
});
|
|
|
|
it.each([
|
|
['ts', 'typescript'], ['tsx', 'tsx'], ['js', 'javascript'], ['jsx', 'jsx'],
|
|
] as const)('peels transparent receivers and drops untyped expression receivers: %s', (ext, language) => {
|
|
const typed = language === 'typescript' || language === 'tsx';
|
|
const result = assertParity(`fixture.${ext}`, `
|
|
function list() { return []; }
|
|
class Runner { go() { return 1; } }
|
|
async function exprReceivers(x, y) {
|
|
(await list()).map(g);
|
|
(x).run();
|
|
${typed ? 'x!.run(); (y as X).run(); (x satisfies X).stop(); getTarget("a")!.install(); if (x && y!.c.has(1)) {} if (x && this.e!.c.has(1)) {}' : ''}
|
|
(a ?? b).map(g);
|
|
arr[0].run();
|
|
f().list.map(g);
|
|
(() => 1).call(null);
|
|
this.a.b.run();
|
|
super.stop();
|
|
new Runner().go();
|
|
window.Api.start();
|
|
}
|
|
`, language);
|
|
const fn = result.nodes.find((n) => n.name === 'exprReceivers');
|
|
expect(result.unresolvedReferences.filter((r) => r.referenceKind === 'calls' && r.fromNodeId === fn!.id)
|
|
.map((r) => r.referenceName)).toEqual([
|
|
'list().map', 'list', 'x.run',
|
|
...(typed ? ['x.run', 'y.run', 'x.stop', 'getTarget().install', 'getTarget', 'has'] : []),
|
|
'f', 'run', 'stop', 'go', 'start',
|
|
]);
|
|
});
|
|
|
|
it.each([
|
|
['ts', 'typescript'], ['tsx', 'tsx'], ['js', 'javascript'], ['jsx', 'jsx'],
|
|
] as const)('walks a module-scope destructuring declaration like a body does: %s (#2340)', (ext, language) => {
|
|
const typed = language === 'typescript' || language === 'tsx';
|
|
const result = assertParity(`fixture.${ext}`, `
|
|
import { handler } from './h';
|
|
const { a } = useFoo(1);
|
|
let [b, c] = pair();
|
|
var { d: { e } } = nested();
|
|
const { f = fallback() } = withDefault(handler);
|
|
const [g = other(), ...rest] = list(() => inArrow(handler));
|
|
export const { h } = exported(new Store());
|
|
export const { useGetUserQuery } = api;
|
|
${typed ? 'const { k }: Shape = make();' : ''}
|
|
function probe() { const { j } = inner(); return j; }
|
|
export function second() { return probe(); }
|
|
`, language);
|
|
const calls = result.unresolvedReferences.filter((r) => r.referenceKind === 'calls').map((r) => r.referenceName);
|
|
expect(calls).toEqual(expect.arrayContaining([
|
|
'useFoo', 'pair', 'nested', 'fallback', 'withDefault', 'other', 'list', 'inArrow', 'exported', 'inner',
|
|
...(typed ? ['make'] : []),
|
|
]));
|
|
});
|
|
|
|
it.each([
|
|
['ts', 'typescript'], ['tsx', 'tsx'],
|
|
] as const)('typed styled tags are components, parsed as comparisons or not: %s', (ext, language) => {
|
|
// `styled.div<Props>\`…\`` parses as `(styled.div < Props) > \`…\``; the
|
|
// type argument's own operators sit between (`<A | B>`, `<Partial<A>>`).
|
|
const result = assertParity(`styles.${ext}`, `
|
|
import styled, { css } from 'styled-components';
|
|
import { s } from './theme';
|
|
type Props = { align: 'start' | 'end' };
|
|
const Plain = styled.div\`color: red;\`;
|
|
export const Wrapper = styled.div<Props>\`color: \${(p) => s(p.align)};\`;
|
|
const CloseAction = styled.div<{ animation: Animation | null }>\`top: 0;\`;
|
|
const Content = styled(Plain)<Props>\`padding: 4px;\`;
|
|
const NudeButton = styled(Plain).attrs((props: Props) => ({ type: "button" }))<Props>\`\`;
|
|
const Either = styled.div<Props | Other>\`color: red;\`;
|
|
const Nested = styled.div<Partial<Props>>\`color: red;\`;
|
|
const Mixin = css<Props>\`color: red;\`;
|
|
const Compared = styled.length < LIMIT > 2;
|
|
const lowerCase = styled.div<Props>\`color: red;\`;
|
|
`, language);
|
|
const kind = (name: string) => result.nodes.filter((n) => n.name === name).map((n) => n.kind);
|
|
for (const name of ['Plain', 'Wrapper', 'CloseAction', 'Content', 'NudeButton', 'Either', 'Nested']) {
|
|
expect(kind(name), name).toEqual(['component']);
|
|
}
|
|
for (const name of ['Mixin', 'Compared', 'lowerCase']) expect(kind(name), name).toEqual(['constant']);
|
|
});
|
|
|
|
it.each([
|
|
['tsx', 'tsx'], ['js', 'javascript'], ['jsx', 'jsx'],
|
|
] as const)('edges the file-scope values a component reads or renders: %s', (ext, language) => {
|
|
// `.jsx` was left out of the value-reference languages on both paths, so
|
|
// this file had none of these edges as .jsx and all of them as .js or .tsx.
|
|
const result = assertParity(`routes.${ext}`, `
|
|
import { lazy } from 'react';
|
|
import Loadable from './Loadable';
|
|
const LoginPage = Loadable(lazy(() => import('./pages/Login')));
|
|
const ROUTE_TABLE = [{ path: '/login', label: 'Login' }];
|
|
const THEME_TOKENS = { color: 'red', size: 12 };
|
|
export function AuthRoutes() { return <LoginPage />; }
|
|
export function Nav() {
|
|
return <ul style={{ color: THEME_TOKENS.color }}>{ROUTE_TABLE.map((r) => <li key={r.path}>{r.label}</li>)}</ul>;
|
|
}
|
|
export const Box = () => <div data-size={THEME_TOKENS.size} />;
|
|
`, language);
|
|
const name = (id: string) => result.nodes.find((n) => n.id === id)?.name;
|
|
expect(result.edges
|
|
.filter((e) => e.kind === 'references' && e.metadata?.valueRef === true)
|
|
.map((e) => `${name(e.source)} -> ${name(e.target)}`)
|
|
.sort()).toEqual(['AuthRoutes -> LoginPage', 'Box -> THEME_TOKENS', 'Nav -> ROUTE_TABLE', 'Nav -> THEME_TOKENS']);
|
|
});
|
|
|
|
it('torture fixture (tsx): components, stores, RTK, fn-refs, value-refs, decorators', () => {
|
|
const file = path.join(FIXTURE_DIR, 'torture.tsx');
|
|
assertParity('fixtures/torture.tsx', fs.readFileSync(file, 'utf8'), 'tsx');
|
|
});
|
|
|
|
it('torture fixture (js): field methods, wrappers, vuex module shape', () => {
|
|
const file = path.join(FIXTURE_DIR, 'torture.js');
|
|
assertParity('fixtures/torture.js', fs.readFileSync(file, 'utf8'), 'javascript');
|
|
});
|
|
|
|
it('torture fixture (java): Lombok, anonymous classes, method refs, chains', () => {
|
|
const file = path.join(FIXTURE_DIR, 'Torture.java');
|
|
assertParity('fixtures/Torture.java', fs.readFileSync(file, 'utf8'), 'java');
|
|
});
|
|
|
|
it('torture fixture (python): decorators, self fn-refs, imports, shadowing', () => {
|
|
const file = path.join(FIXTURE_DIR, 'torture.py');
|
|
assertParity('fixtures/torture.py', fs.readFileSync(file, 'utf8'), 'python');
|
|
});
|
|
|
|
it.each(['LF', 'CRLF'])('Python body docstrings parity (%s, #1905)', (ending) => {
|
|
const source = fs.readFileSync(path.join(FIXTURE_DIR, 'docstrings.py'), 'utf8');
|
|
const result = assertParity('ledger.py', ending === 'CRLF' ? source.replace(/\n/g, '\r\n') : source, 'python');
|
|
expect(result.nodes.find((n) => n.kind === 'file')?.docstring).toBe('Ledger module documentation.');
|
|
expect(result.nodes.find((n) => n.name === 'settle')?.docstring).toBe('Method comment.\n\nSettle the ledger.');
|
|
});
|
|
|
|
it('torture fixture (go): receivers, embedding, interfaces, composite literals', () => {
|
|
const file = path.join(FIXTURE_DIR, 'torture.go');
|
|
assertParity('fixtures/torture.go', fs.readFileSync(file, 'utf8'), 'go');
|
|
});
|
|
|
|
it('Python member values preserve receivers across callback, assignment and collection positions (#1820)', () => {
|
|
const result = assertParity('members.py', `
|
|
class Store:
|
|
def fetch(self, ids):
|
|
return ids
|
|
class Consumer:
|
|
def wire(self, pool, obj):
|
|
pool.submit(self.store.fetch, obj.fetch)
|
|
cb = self.store.fetch
|
|
table = [obj.fetch, Store.fetch, self.fetch, cls.fetch]
|
|
keyword(callback=obj.fetch)
|
|
obj.fetch([])
|
|
pool.submit(factory().fetch, obj[0].fetch)
|
|
`, 'python');
|
|
const names = result.unresolvedReferences.filter(r => r.referenceKind === 'function_ref').map(r => r.referenceName);
|
|
expect(names.sort()).toEqual(['Store.fetch', 'cls.fetch', 'obj.fetch', 'self.fetch', 'self.store.fetch']);
|
|
expect(result.unresolvedReferences.some(r => r.referenceKind === 'calls' && r.referenceName === 'obj.fetch')).toBe(true);
|
|
});
|
|
|
|
it('Go method values preserve receivers and exclude invocation receivers (#1820)', () => {
|
|
const result = assertParity('members.go', `package demo
|
|
type Store struct{}
|
|
func (s *Store) Fetch() {}
|
|
func wire(c *Store, pool Pool) {
|
|
Submit(c.Fetch)
|
|
cb := c.Fetch
|
|
table := []func(){c.Fetch, Store.Fetch}
|
|
Submit(c.store.Fetch)
|
|
go c.Fetch()
|
|
Submit(factory().Fetch, items[0].Fetch)
|
|
}
|
|
`, 'go');
|
|
const names = result.unresolvedReferences.filter(r => r.referenceKind === 'function_ref').map(r => r.referenceName);
|
|
expect(names.sort()).toEqual(['Store.Fetch', 'c.Fetch', 'c.store.Fetch']);
|
|
expect(result.unresolvedReferences.some(r => r.referenceKind === 'calls' && r.referenceName === 'c.Fetch')).toBe(true);
|
|
});
|
|
|
|
it.each(['LF', 'CRLF'])('Go selector values stoplist the whole name, not the field (%s)', (ending) => {
|
|
// The stoplist holds bare words like Python's `None`; `raft.None` (etcd)
|
|
// and cgo's `C.NULL` are still values. The name is operand + field, so a
|
|
// break or comment after the dot keeps it; one inside the operand doesn't.
|
|
const source = `package demo
|
|
import "example.com/raft"
|
|
type Store struct{}
|
|
func (s *Store) new() any { return nil }
|
|
func wire(s *Store) {
|
|
Submit(raft.None, C.NULL, None, nil)
|
|
pool := sync.Pool{New: s.new}
|
|
Submit(raft.
|
|
Next, raft./* c */ Prev, raft.// c
|
|
Last)
|
|
Submit(s.
|
|
inner.Fetch)
|
|
_ = pool
|
|
}
|
|
`;
|
|
const result = assertParity('values.go', ending === 'CRLF' ? source.replace(/\n/g, '\r\n') : source, 'go');
|
|
const names = result.unresolvedReferences.filter(r => r.referenceKind === 'function_ref').map(r => r.referenceName);
|
|
expect(names.sort()).toEqual(['C.NULL', 'raft.Last', 'raft.Next', 'raft.None', 'raft.Prev', 's.new']);
|
|
});
|
|
|
|
it.each(REAL_SOURCES)('real source parity: %s', (rel) => {
|
|
const file = path.join(__dirname, '..', rel);
|
|
assertParity(rel, fs.readFileSync(file, 'utf8'), 'typescript');
|
|
});
|
|
|
|
// Every torture fixture again with CRLF line endings — the shape every
|
|
// Windows autocrlf checkout has. Derived in memory (not a checked-in CRLF
|
|
// file) so no platform or editor can silently normalize it away. Pins the
|
|
// JS-multiline-^ semantics in the kernel's docstring cleaning: JS `^`/m
|
|
// anchors after \r too, so the block-continuation `\s*` eats the `\n` and
|
|
// the cleaned docstring keeps a bare `\r` (caught on the Windows VM leg of
|
|
// the O2 gate; diverged in the kernel until docstring.rs mirrored it).
|
|
it.each([
|
|
['torture.tsx', 'tsx'],
|
|
['torture.js', 'javascript'],
|
|
['Torture.java', 'java'],
|
|
['torture.py', 'python'],
|
|
['torture.go', 'go'],
|
|
] as const)('torture fixture CRLF parity: %s', (name, lang) => {
|
|
const file = path.join(FIXTURE_DIR, name);
|
|
const crlf = fs.readFileSync(file, 'utf8').replace(/(?<!\r)\n/g, '\r\n');
|
|
assertParity(`fixtures/${name} (crlf)`, crlf, lang);
|
|
});
|
|
|
|
it('files with parse errors defer to the wasm extractor (recovery is encoding-dependent)', () => {
|
|
// tree-sitter error RECOVERY differs between UTF-8 (native) and UTF-16
|
|
// (web-tree-sitter) parsing — same grammar, same core version — so the
|
|
// kernel defers any erroring file to keep routing graph-neutral.
|
|
const broken = 'export function f( {\n return }} 12 (\n';
|
|
process.env.CODEGRAPH_KERNEL_LANGS = 'all';
|
|
delete process.env.CODEGRAPH_KERNEL;
|
|
expect(tryKernelExtract('src/broken.ts', broken, 'typescript')).toBeNull();
|
|
// The seam still serves the file — through the wasm path.
|
|
process.env.CODEGRAPH_KERNEL = '0';
|
|
const viaWasm = extractFromSource('src/broken.ts', broken, 'typescript');
|
|
delete process.env.CODEGRAPH_KERNEL;
|
|
expect(viaWasm.nodes.some((n) => n.kind === 'file')).toBe(true);
|
|
});
|
|
|
|
it('typescript fixture parsed as plain typescript variant', () => {
|
|
// Same content through the non-tsx grammar exercises the typescript
|
|
// (vs tsx) LangSpec pairing.
|
|
const file = path.join(__dirname, '..', 'src/extraction/kernel/index.ts');
|
|
assertParity('src/extraction/kernel/index.ts', fs.readFileSync(file, 'utf8'), 'typescript');
|
|
});
|
|
});
|