@alint-js/languages 0.1.5

package/dist/index.mjs

@@ -0,0 +1,288 @@
+import { createRequire } from "node:module";
+import { sliceRange, targetIdentity, withLanguage, withStableIdentities } from "@alint-js/core";
+import Parser from "web-tree-sitter";
+import { dirname, join } from "node:path";
+//#region ../plugin/dist/index.mjs
+function definePlugin(plugin) {
+	return plugin;
+}
+//#endregion
+//#region src/grammar.ts
+const grammarDir = join(dirname(createRequire(import.meta.url).resolve("tree-sitter-wasms/package.json")), "out");
+/**
+* Which languages this package provides, and the grammar each is parsed with. Adding a language
+* starts here: `LanguageId` is derived from these keys, and `QUERIES` must then cover it too.
+*
+* Ids are spelled as editors spell them, per the convention on `LanguageDefinition.name`.
+* TypeScript and JavaScript are deliberately missing — core's oxc producer already owns those
+* extensions, and `registerLanguage` throws when two plugins claim the same one.
+*/
+const GRAMMAR = {
+	go: "tree-sitter-go.wasm",
+	python: "tree-sitter-python.wasm",
+	rust: "tree-sitter-rust.wasm"
+};
+let ready;
+const grammars = /* @__PURE__ */ new Map();
+async function grammarFor(language) {
+	ready ??= Parser.init();
+	await ready;
+	let grammar = grammars.get(language);
+	if (grammar === void 0) {
+		grammar = await Parser.Language.load(join(grammarDir, GRAMMAR[language]));
+		grammars.set(language, grammar);
+	}
+	return grammar;
+}
+function isLanguageId(value) {
+	return Object.hasOwn(GRAMMAR, value);
+}
+const QUERIES = {
+	go: `
+(function_declaration) @function
+(method_declaration) @function
+(comment) @comment
+(call_expression function: (identifier) @call)
+(call_expression function: (selector_expression field: (field_identifier) @call))
+(identifier) @identifier
+
+(function_declaration name: (identifier) @binder)
+(parameter_declaration name: (identifier) @binder)
+(variadic_parameter_declaration name: (identifier) @binder)
+(short_var_declaration left: (expression_list (identifier) @binder))
+(var_spec name: (identifier) @binder)
+(const_spec name: (identifier) @binder)
+(range_clause left: (expression_list (identifier) @binder))
+`,
+	python: `
+(function_definition) @function
+(comment) @comment
+(function_definition body: (block . (expression_statement (string) @comment)))
+(call function: (identifier) @call)
+(call function: (attribute attribute: (identifier) @call))
+(identifier) @identifier
+(attribute attribute: (identifier) @anchor)
+(keyword_argument name: (identifier) @anchor)
+
+(function_definition name: (identifier) @binder)
+(parameters (identifier) @binder)
+(default_parameter name: (identifier) @binder)
+(typed_parameter (identifier) @binder)
+(typed_default_parameter name: (identifier) @binder)
+(assignment left: (identifier) @binder)
+(for_statement left: (identifier) @binder)
+(lambda_parameters (identifier) @binder)
+`,
+	rust: `
+(function_item) @function
+(line_comment) @comment
+(block_comment) @comment
+(call_expression function: (identifier) @call)
+(call_expression function: (field_expression field: (field_identifier) @call))
+(call_expression function: (scoped_identifier name: (identifier) @call))
+(identifier) @identifier
+
+(function_item name: (identifier) @binder)
+(parameter pattern: (identifier) @binder)
+(let_declaration pattern: (identifier) @binder)
+(closure_parameters (identifier) @binder)
+`
+};
+//#endregion
+//#region src/extract.ts
+const queries = /* @__PURE__ */ new Map();
+/**
+* One file target carrying every call site, then one function target per function, each with the
+* `FunctionInfo` a consumer would otherwise need its own parser to work out.
+*
+* The language comes from the file rather than a second argument, because every target carries that
+* same file and the two could then disagree. Pass the file through `withLanguage` first.
+*/
+async function extractTargets(file) {
+	if (!isLanguageId(file.language)) throw new Error(`Language "${file.language}" is not provided by @alint-js/languages.`);
+	const language = file.language;
+	const grammar = await grammarFor(language);
+	const parser = new Parser();
+	parser.setLanguage(grammar);
+	const tree = parser.parse(file.text);
+	let query = queries.get(language);
+	if (query === void 0) {
+		query = grammar.query(QUERIES[language]);
+		queries.set(language, query);
+	}
+	const calls = [];
+	const comments = [];
+	const identifiers = [];
+	const anchored = /* @__PURE__ */ new Set();
+	const binders = [];
+	const functionNodes = [];
+	for (const { name, node } of query.captures(tree.rootNode)) switch (name) {
+		case "anchor":
+			anchored.add(node.startIndex);
+			break;
+		case "binder":
+			binders.push(node);
+			break;
+		case "call":
+			calls.push({
+				name: node.text,
+				range: rangeOf(node)
+			});
+			break;
+		case "comment":
+			comments.push(rangeOf(node));
+			break;
+		case "function":
+			functionNodes.push(node);
+			break;
+		case "identifier":
+			identifiers.push(rangeOf(node));
+			break;
+	}
+	const renameable = identifiers.filter((range) => !anchored.has(range.start));
+	const commentStarts = new Set(comments.map((range) => range.start));
+	const functionTargets = functionNodes.map((node) => functionTarget(node, file, language, comments, commentStarts, renameable, binders));
+	return [fileTarget(file, calls), ...withStableIdentities(functionTargets)];
+}
+/**
+* The body's statements, comments left out.
+*
+* All three grammars make a comment a named child of the block it sits in, so comments have to be
+* filtered out here. Leave them in and adding a comment to a one-line function makes it look two
+* statements long.
+*/
+function bodyStatements(node, commentStarts) {
+	const body = node.childForFieldName("body");
+	if (body === null) return [];
+	const statements = [];
+	for (let index = 0; index < body.namedChildCount; index += 1) {
+		const child = body.namedChild(index);
+		if (child !== null && !commentStarts.has(child.startIndex)) statements.push(child);
+	}
+	return statements;
+}
+function fileTarget(file, calls) {
+	return {
+		file,
+		identity: "file",
+		kind: "file",
+		language: file.language,
+		metadata: { calls },
+		origin: { physicalPath: file.path },
+		text: file.text
+	};
+}
+function functionTarget(node, file, language, comments, commentStarts, identifiers, binders) {
+	const range = rangeOf(node);
+	const source = sliceRange(file, range);
+	const nameNode = node.childForFieldName("name");
+	const name = nameNode?.text;
+	const statements = bodyStatements(node, commentStarts);
+	const exported = isExported(node, language, name ?? "");
+	const info = {
+		bodyIsSingleExpression: statements.length === 1 && !holdsBlock(statements[0]),
+		bodyStatements: statements.length,
+		commentRanges: rangesInside(comments, range),
+		declaredNames: [.../* @__PURE__ */ new Set([...binders.filter((binder) => binder.startIndex >= range.start && binder.endIndex <= range.end).map((binder) => binder.text), ...name === void 0 ? [] : [name]])],
+		exported,
+		identifierRanges: withOwnName(rangesInside(identifiers, range), nameNode, range)
+	};
+	return {
+		file,
+		identity: targetIdentity("function", name, range),
+		kind: "function",
+		language: file.language,
+		loc: source.loc,
+		metadata: {
+			exported,
+			function: info
+		},
+		name,
+		origin: {
+			physicalPath: file.path,
+			range
+		},
+		range,
+		text: source.text
+	};
+}
+/** Whether anything under this node is a block, which is how all three grammars write a branch or a loop. */
+function holdsBlock(node) {
+	const pending = [...node.namedChildren];
+	while (pending.length > 0) {
+		const next = pending.pop();
+		if (next === void 0) continue;
+		if (next.type === "block") return true;
+		pending.push(...next.namedChildren);
+	}
+	return false;
+}
+/** Reachable from outside its file. Go says it with a capital, Python with the absence of a leading underscore, Rust with `pub`. */
+function isExported(node, language, name) {
+	switch (language) {
+		case "go": return /^[A-Z]/.test(name);
+		case "python": return !name.startsWith("_");
+		case "rust": return node.children.some((child) => child.type === "visibility_modifier");
+	}
+}
+/** `web-tree-sitter` counts in JavaScript string indexes, not UTF-8 bytes, so `text.slice(start, end)` is correct. */
+function rangeOf(node) {
+	return {
+		end: node.endIndex,
+		start: node.startIndex
+	};
+}
+/** Rebases the ranges inside `outer` onto the function's own `text`, which is where `FunctionInfo` says they point. */
+function rangesInside(ranges, outer) {
+	return ranges.filter((range) => range.start >= outer.start && range.end <= outer.end).map((range) => ({
+		end: range.end - outer.start,
+		start: range.start - outer.start
+	}));
+}
+/**
+* Adds the function's own name to its renameable identifiers.
+*
+* This only has anything to add for a Go method, whose name is a `field_identifier` rather than an
+* `identifier`. The Go query leaves `field_identifier` out on purpose, because reading a struct
+* field is not renameable, but a method naming itself is. Every other name the queries capture is
+* already an `@identifier`, so the dedupe by start offset drops the second copy.
+*/
+function withOwnName(ranges, nameNode, outer) {
+	if (nameNode === null) return ranges;
+	const name = {
+		end: nameNode.endIndex - outer.start,
+		start: nameNode.startIndex - outer.start
+	};
+	if (ranges.some((range) => range.start === name.start)) return ranges;
+	return [...ranges, name].sort((left, right) => left.start - right.start);
+}
+//#endregion
+//#region src/index.ts
+const goLanguage = {
+	extensions: [".go"],
+	extract: (file) => extractTargets(withLanguage(file, "go")),
+	name: "go"
+};
+const pythonLanguage = {
+	extensions: [".py"],
+	extract: (file) => extractTargets(withLanguage(file, "python")),
+	name: "python"
+};
+const rustLanguage = {
+	extensions: [".rs"],
+	extract: (file) => extractTargets(withLanguage(file, "rust")),
+	name: "rust"
+};
+/**
+* A plugin that declares languages and nothing else: no rules, no processors.
+*
+* The alias a config registers it under does not matter, because languages register under their own
+* names. Once registered, they serve every plugin's rules, not just this one's.
+*/
+const languagesPlugin = definePlugin({ languages: {
+	go: goLanguage,
+	python: pythonLanguage,
+	rust: rustLanguage
+} });
+//#endregion
+export { languagesPlugin as default, languagesPlugin, extractTargets, goLanguage, pythonLanguage, rustLanguage };

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@alint-js/languages",
+  "type": "module",
+  "version": "0.1.5",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "@alint-js/core": "0.1.5"
+  },
+  "dependencies": {
+    "tree-sitter-wasms": "^0.1.13",
+    "web-tree-sitter": "^0.24.7"
+  },
+  "devDependencies": {
+    "@alint-js/core": "0.1.5",
+    "@alint-js/plugin": "0.1.5"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run --config vitest.config.ts"
+  }
+}