Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/lsp/__bench__/evidence.ts

Raw
import assert from "node:assert/strict";
import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { isAbsolute, join, relative, resolve, sep } from "node:path";
import { pathToFileURL } from "node:url";
import type { Client } from "../src/client.ts";
import { normalize } from "../src/result.ts";
import { fromPosition, snapshot } from "../src/source.ts";

const evidence = resolve(process.argv[2] ?? "");
const relativeEvidence = relative(tmpdir(), evidence);
assert(
	isAbsolute(process.argv[2] ?? "") &&
		relativeEvidence !== "" &&
		relativeEvidence !== ".." &&
		!relativeEvidence.startsWith(`..${sep}`) &&
		!isAbsolute(relativeEvidence),
	"Provide dedicated OS-temp evidence directory.",
);
await mkdir(evidence, { recursive: true });
const root = await mkdtemp(join(tmpdir(), "lsp-evidence-bench-"));
const file = join(root, "sample.go");
const text = `var Value = 1\n${"// realistic source line\n".repeat(4000)}`;
await writeFile(file, text);
const location = {
	uri: pathToFileURL(file).href,
	range: { start: { line: 0, character: 4 }, end: { line: 0, character: 9 } },
};
const client = {
	root,
	encoding: "utf-16",
	remember: async () => undefined,
} as unknown as Client;
const signal = new AbortController().signal;
const late = {
	uri: location.uri,
	range: {
		start: { line: 4000, character: 3 },
		end: { line: 4000, character: 12 },
	},
};
async function references(
	hit: typeof location,
	snippet: string,
): Promise<void> {
	for (let i = 0; i < 3; i++) {
		const output = await normalize(
			client,
			"references",
			file,
			Array.from({ length: 50 }, () => hit),
			50,
			32768,
			signal,
		);
		assert.deepEqual(
			output.items,
			Array.from({ length: 50 }, () => ({
				file,
				range: {
					start: {
						line: hit.range.start.line + 1,
						column: hit.range.start.character + 1,
					},
					end: {
						line: hit.range.end.line + 1,
						column: hit.range.end.character + 1,
					},
				},
				snippet,
			})),
		);
		assert.equal(output.toolTruncated, false);
	}
}
const workloads = {
	snapshot: async () => {
		for (let i = 0; i < 20; i++) assert.equal(await snapshot(file), text);
	},
	references: () => references(location, "var Value = 1"),
	lateReferences: () => references(late, "// realistic source line"),
	latePosition: async () => {
		for (let i = 0; i < 100; i++) {
			assert.deepEqual(fromPosition(text, late.range.start, "utf-16"), {
				line: 4001,
				column: 4,
			});
		}
	},
};
const rounds = 12;
const warmup = 3;
const samples: Record<string, number[]> = {};
try {
	for (const [name, work] of Object.entries(workloads)) {
		for (let i = 0; i < warmup; i++) await work();
		samples[name] = [];
		for (let i = 0; i < rounds; i++) {
			global.gc?.();
			const start = performance.now();
			await work();
			samples[name]?.push(performance.now() - start);
		}
	}
	const report = {
		node: process.version,
		platform: process.platform,
		warmup,
		rounds,
		fixtureBytes: Buffer.byteLength(text),
		method:
			"Per batch: 20 snapshots, 3 reference normalizations of 50 hits (first/4001st line), or 100 late-line position conversions, in one 100014-byte file. remember stubbed; three discarded warmups, GC between rounds; raw samples retained, no outliers removed.",
		samples,
	};
	await writeFile(
		join(evidence, "timing.json"),
		JSON.stringify(report, null, 2),
	);
	console.log(JSON.stringify(report));
} finally {
	await rm(root, { recursive: true, force: true });
}