prettier-plugin-wolfram 0.7.0

package/src/parser/cstEqual.js

@@ -0,0 +1,18 @@
+const TRIVIA = new Set(["Whitespace", "Token`Whitespace", "Newline", "Token`Newline"]);
+
+export function stripTrivia(node) {
+	if (!node || typeof node !== "object") return node;
+	const copy = { ...node };
+	delete copy.locStart; delete copy.locEnd; // offsets are derived downstream
+	if (Array.isArray(copy.children)) {
+		copy.children = copy.children
+			.filter((c) => !(c?.type === "LeafNode" && TRIVIA.has(c.kind)))
+			.map(stripTrivia);
+	}
+	if (copy.head) copy.head = stripTrivia(copy.head);
+	return copy;
+}
+
+export function cstEqualModuloTrivia(a, b) {
+	return JSON.stringify(stripTrivia(a)) === JSON.stringify(stripTrivia(b));
+}

package/src/parser/index.js

@@ -0,0 +1,29 @@
+import { Parser, Language } from "web-tree-sitter";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { readFileSync } from "fs";
+import { adapt } from "./adapter.js";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const WASM_PATH = resolve(here, "tree-sitter-wolfram.wasm");
+
+let _langPromise = null;
+async function getLanguage() {
+	if (!_langPromise) {
+		_langPromise = (async () => {
+			await Parser.init();
+			return Language.load(readFileSync(WASM_PATH));
+		})();
+	}
+	return _langPromise;
+}
+
+export class WolframParser {
+	async getCST(sourceText) {
+		const lang = await getLanguage();
+		const parser = new Parser();
+		parser.setLanguage(lang);
+		const tree = parser.parse(sourceText);
+		return adapt(tree, sourceText);
+	}
+}

package/src/parser/operators.js

@@ -0,0 +1,35 @@
+export const INFIX_OPS = {
+	",": "Comma", ";": "CompoundExpression",
+	"+": "Plus", "-": "Plus", "*": "Times", "/": "Divide",
+	".": "Dot", "**": "NonCommutativeMultiply",
+	"~~": "StringExpression", "<>": "StringJoin",
+	"|": "Alternatives", "||": "Or", "&&": "And",
+	"===": "SameQ", "=!=": "UnsameQ",
+	"==": "Equal", "!=": "Unequal", "<": "Less", "<=": "LessEqual",
+	">": "Greater", ">=": "GreaterEqual",
+	"@*": "Composition", "/*": "RightComposition",
+};
+export const BINARY_OPS = {
+	"=": "Set", ":=": "SetDelayed", "^=": "UpSet", "^:=": "UpSetDelayed",
+	"->": "Rule", ":>": "RuleDelayed", "<->": "TwoWayRule", "|->": "Function",
+	"/;": "Condition", "/.": "ReplaceAll", "//.": "ReplaceRepeated",
+	"/:": "TagSet", "//": "BinarySlashSlash", "//=": "ApplyTo",
+	"+=": "AddTo", "-=": "SubtractFrom", "*=": "TimesBy", "/=": "DivideBy",
+	"/": "Divide",
+	"^": "Power", "@": "BinaryAt", "@@": "Apply", "@@@": "Apply",
+	"/@": "Map", "//@": "MapAll", "?": "PatternTest", ":": "Pattern",
+};
+export const PREFIX_OPS = {
+	"-": "Minus", "+": "Plus", "!": "Not", "!!": "Not",
+	"++": "PreIncrement", "--": "PreDecrement",
+};
+export const POSTFIX_OPS = {
+	"&": "Function", "..": "Repeated", "...": "RepeatedNull",
+	"'": "Derivative", "!": "Factorial", "!!": "Factorial2",
+	"++": "Increment", "--": "Decrement", "=.": "Unset",
+};
+export function opName(table, literal) {
+	const op = table[literal];
+	if (op === undefined) throw new Error(`unmapped operator: ${JSON.stringify(literal)}`);
+	return op;
+}

package/src/parser/position.js

@@ -0,0 +1,62 @@
+// Convert tree-sitter character offsets to CodeParser 1-based [line,col] source.
+//
+// CodeParser (WL's official parser) uses a byte-based column model with two quirks:
+//   1. Non-ASCII UTF-8 characters are counted by byte width, not character count.
+//   2. Tab characters (\t, byte 0x09) are counted as 2 bytes/columns wide.
+//
+// web-tree-sitter uses JS character (UTF-16 code unit) offsets internally, so we
+// pre-build a char→"WL byte" offset map here and use it in nodeSource().
+
+export function makeLineIndex(source) {
+	// charToWlOffset[i] = WL byte offset of the i-th JS code unit in source.
+	const charToWlOffset = new Int32Array(source.length + 1);
+	let wlOff = 0;
+	for (let i = 0; i < source.length; i++) {
+		charToWlOffset[i] = wlOff;
+		const code = source.charCodeAt(i);
+		if (code === 0x09) {
+			// Tab: WL CodeParser counts it as 2 columns.
+			wlOff += 2;
+		} else if (code < 0x80) {
+			wlOff += 1;
+		} else if (code >= 0xd800 && code <= 0xdbff) {
+			// High surrogate: part of a surrogate pair (4 UTF-8 bytes total).
+			wlOff += 4;
+			i++; // Skip the low surrogate (next code unit).
+			charToWlOffset[i] = wlOff - 2; // low surrogate maps to same 4-byte run
+		} else if (code < 0x800) {
+			wlOff += 2;
+		} else {
+			wlOff += 3;
+		}
+	}
+	charToWlOffset[source.length] = wlOff;
+
+	// Build line start array in WL byte offsets.
+	const lineStarts = [0];
+	for (let i = 0; i < source.length; i++) {
+		if (source[i] === "\n") lineStarts.push(charToWlOffset[i + 1]);
+	}
+
+	return { charToWlOffset, lineStarts };
+}
+
+export function offsetToLineCol(lineIndex, charOffset) {
+	const wlOffset = lineIndex.charToWlOffset[charOffset];
+	const { lineStarts } = lineIndex;
+	// Binary search for the greatest line start <= wlOffset.
+	let lo = 0, hi = lineStarts.length - 1, line = 0;
+	while (lo <= hi) {
+		const mid = (lo + hi) >> 1;
+		if (lineStarts[mid] <= wlOffset) { line = mid; lo = mid + 1; }
+		else hi = mid - 1;
+	}
+	return [line + 1, wlOffset - lineStarts[line] + 1];
+}
+
+export function nodeSource(tsNode, lineIndex) {
+	return [
+		offsetToLineCol(lineIndex, tsNode.startIndex),
+		offsetToLineCol(lineIndex, tsNode.endIndex),
+	];
+}

package/src/range.js

@@ -0,0 +1,98 @@
+function isIgnorableTopLevelChild(node) {
+	return (
+		node?.type === "LeafNode" &&
+		["Token`Whitespace", "Token`Newline"].includes(node.kind)
+	);
+}
+
+function findLastIndex(values, predicate) {
+	for (let index = values.length - 1; index >= 0; index -= 1) {
+		if (predicate(values[index], index)) {
+			return index;
+		}
+	}
+
+	return -1;
+}
+
+export function getFormattableTopLevelChildren(ast) {
+	const children = Array.isArray(ast?.children) ? ast.children : [];
+
+	return children.filter(
+		(node) =>
+			!isIgnorableTopLevelChild(node) &&
+			typeof node.locStart === "number" &&
+			typeof node.locEnd === "number",
+	);
+}
+
+export function snapRangeToTopLevelChildren(ast, rangeStart, rangeEnd) {
+	if (ast?.type === "UnformattableNode") {
+		return null;
+	}
+
+	if (
+		typeof rangeStart !== "number" ||
+		typeof rangeEnd !== "number" ||
+		!Number.isFinite(rangeStart) ||
+		!Number.isFinite(rangeEnd) ||
+		rangeStart >= rangeEnd
+	) {
+		return null;
+	}
+
+	const children = getFormattableTopLevelChildren(ast);
+	if (children.length === 0) {
+		return null;
+	}
+
+	let startIndex = children.findIndex((child) => child.locEnd > rangeStart);
+	if (startIndex === -1) {
+		startIndex = 0;
+	}
+
+	let endIndex = findLastIndex(
+		children,
+		(child) => child.locStart < rangeEnd,
+	);
+	if (endIndex === -1) {
+		endIndex = children.length - 1;
+	}
+
+	if (endIndex < startIndex) {
+		endIndex = startIndex;
+	}
+
+	return {
+		children,
+		startIndex,
+		endIndex,
+		rangeStart: children[startIndex].locStart,
+		rangeEnd: children[endIndex].locEnd,
+	};
+}
+
+export function preprocessRange(ast, opts) {
+	if (!ast || ast.type === "UnformattableNode") {
+		return ast;
+	}
+
+	if (!opts || (opts.rangeStart === 0 && opts.rangeEnd === Infinity)) {
+		return ast;
+	}
+
+	const snappedRange = snapRangeToTopLevelChildren(
+		ast,
+		opts.rangeStart,
+		opts.rangeEnd,
+	);
+
+	if (!snappedRange) {
+		return ast;
+	}
+
+	opts.rangeStart = snappedRange.rangeStart;
+	opts.rangeEnd = snappedRange.rangeEnd;
+
+	return ast;
+}

package/src/rules/index.js

@@ -0,0 +1,57 @@
+// src/rules/index.js
+import { readdirSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { normalizeWolframOptions } from "../options.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Auto-discover rule modules by listing this directory
+async function loadRules() {
+	const files = readdirSync(__dirname).filter(
+		(f) => f.endsWith(".js") && f !== "index.js",
+	);
+	const modules = await Promise.all(
+		files.map((f) => import(join(__dirname, f))),
+	);
+	return modules.map((m) => m.default);
+}
+
+/**
+ * Run all lint rules over a CST node tree.
+ * Returns an array of diagnostics: { rule, message, node, level }.
+ */
+export async function runRules(rootNode, lintRuleOverrides = {}, options = {}) {
+	const rules = await loadRules();
+	const diagnostics = [];
+	const normalizedOptions = normalizeWolframOptions(options);
+
+	for (const rule of rules) {
+		const level = lintRuleOverrides[rule.name] ?? rule.defaultLevel;
+		if (level === "off") continue;
+
+		const context = {
+			options: normalizedOptions,
+			report({ node, message }) {
+				diagnostics.push({
+					rule: rule.name,
+					message,
+					node,
+					level,
+					fixableByFormatter: Boolean(rule.fixableByFormatter),
+				});
+			},
+		};
+
+		walkCST(rootNode, (node) => rule.visit(node, context));
+	}
+
+	return diagnostics;
+}
+
+function walkCST(node, fn) {
+	if (!node || typeof node !== "object") return;
+	fn(node);
+	if (node.children) node.children.forEach((c) => walkCST(c, fn));
+	if (node.head) walkCST(node.head, fn);
+}

package/src/rules/line-width.js

@@ -0,0 +1,129 @@
+// src/rules/line-width.js
+
+export default {
+	name: "line-width",
+	description: "Line exceeds configured printWidth",
+	defaultLevel: "warn",
+	fixableByFormatter: true,
+
+	visit(node, context) {
+		if (node.type !== "ContainerNode") return;
+
+		const maxWidth = context.options?.printWidth ?? 80;
+		const sourceText = String(context.options?.__sourceText ?? "");
+		const overflows = lineOverflowRangesIgnoringComments(
+			sourceText,
+			maxWidth,
+		);
+
+		for (const overflow of overflows) {
+			context.report({
+				node: {
+					source: [
+						[overflow.line, overflow.startCol],
+						[overflow.line, overflow.endCol],
+					],
+				},
+				message: `Line exceeds printWidth (${maxWidth}).`,
+			});
+		}
+	},
+};
+
+function lineOverflowRangesIgnoringComments(sourceText, maxWidth) {
+	const overflows = [];
+	let line = 1;
+	let rawCol = 1;
+	let commentDepth = 0;
+	let inString = false;
+	let escape = false;
+	let keptChars = [];
+	let keptCols = [];
+
+	const flushLine = () => {
+		let visibleLength = keptChars.length;
+		while (
+			visibleLength > 0 &&
+			/[ \t]/.test(keptChars[visibleLength - 1])
+		) {
+			visibleLength--;
+		}
+
+		if (visibleLength > maxWidth) {
+			overflows.push({
+				line,
+				startCol: keptCols[maxWidth],
+				endCol: keptCols[visibleLength - 1] + 1,
+			});
+		}
+
+		keptChars = [];
+		keptCols = [];
+		line++;
+		rawCol = 1;
+	};
+
+	for (let i = 0; i < sourceText.length; i++) {
+		const ch = sourceText[i];
+		const next = sourceText[i + 1];
+
+		if (ch === "\r") continue;
+		if (ch === "\n") {
+			flushLine();
+			continue;
+		}
+
+		if (commentDepth > 0) {
+			if (ch === "(" && next === "*") {
+				commentDepth++;
+				rawCol += 2;
+				i++;
+				continue;
+			}
+			if (ch === "*" && next === ")") {
+				commentDepth--;
+				rawCol += 2;
+				i++;
+				continue;
+			}
+			rawCol++;
+			continue;
+		}
+
+		if (inString) {
+			keptChars.push(ch);
+			keptCols.push(rawCol);
+			if (escape) {
+				escape = false;
+			} else if (ch === "\\") {
+				escape = true;
+			} else if (ch === '"') {
+				inString = false;
+			}
+			rawCol++;
+			continue;
+		}
+
+		if (ch === '"') {
+			inString = true;
+			keptChars.push(ch);
+			keptCols.push(rawCol);
+			rawCol++;
+			continue;
+		}
+
+		if (ch === "(" && next === "*") {
+			commentDepth++;
+			rawCol += 2;
+			i++;
+			continue;
+		}
+
+		keptChars.push(ch);
+		keptCols.push(rawCol);
+		rawCol++;
+	}
+
+	flushLine();
+	return overflows;
+}

package/src/rules/newlines-between-definitions.js

@@ -0,0 +1,103 @@
+// src/rules/newlines-between-definitions.js
+import { blankLinesForCodeGap } from "../utils/codeSpacing.js";
+
+export default {
+	name: "newlines-between-definitions",
+	description:
+		"Top-level declarations and preserved code gaps should match configured blank-line spacing; leading comments stay attached to the following statement",
+	defaultLevel: "warn",
+	fixableByFormatter: true,
+
+	visit(node, context) {
+		if (node.type !== "ContainerNode") return;
+		const children = (node.children ?? []).filter(
+			(c) => !isWhitespaceTrivia(c),
+		);
+
+		let previousGroup = null;
+		let pendingLeadingCommentStartLine = null;
+		let pendingLeadingCommentEndLine = null;
+
+		for (const child of children) {
+			if (isComment(child)) {
+				const startLine = child.source?.[0]?.[0] ?? 0;
+				const endLine = child.source?.[1]?.[0] ?? startLine;
+
+				if (previousGroup && startLine <= previousGroup.endLine) {
+					previousGroup = {
+						...previousGroup,
+						endLine: Math.max(previousGroup.endLine, endLine),
+					};
+					continue;
+				}
+
+				pendingLeadingCommentStartLine ??= startLine;
+				pendingLeadingCommentEndLine = endLine;
+				continue;
+			}
+
+			const currStartLine = child.source?.[0]?.[0] ?? 0;
+			const groupStartLine =
+				pendingLeadingCommentStartLine ?? currStartLine;
+			const leadingCommentGap =
+				pendingLeadingCommentEndLine == null
+					? 0
+					: Math.max(
+							0,
+							currStartLine - pendingLeadingCommentEndLine - 1,
+						);
+
+			if (leadingCommentGap !== 0) {
+				context.report({
+					node: child,
+					message: `Expected 0 blank lines between a leading comment block and the following top-level statement, found ${leadingCommentGap}.`,
+				});
+			}
+
+			if (!previousGroup) {
+				previousGroup = {
+					node: child,
+					endLine: child.source?.[1]?.[0] ?? 0,
+				};
+				pendingLeadingCommentStartLine = null;
+				pendingLeadingCommentEndLine = null;
+				continue;
+			}
+
+			const gap = groupStartLine - previousGroup.endLine - 1;
+			const expected = blankLinesForCodeGap(
+				previousGroup.node,
+				child,
+				gap,
+				context.options,
+				{ topLevel: true },
+			);
+			if (gap !== expected) {
+				context.report({
+					node: child,
+					message: `Expected ${expected} blank line${expected === 1 ? "" : "s"} between top-level statements, found ${gap}.`,
+				});
+			}
+
+			previousGroup = {
+				node: child,
+				endLine: child.source?.[1]?.[0] ?? previousGroup.endLine,
+			};
+			pendingLeadingCommentStartLine = null;
+			pendingLeadingCommentEndLine = null;
+		}
+	},
+};
+
+function isWhitespaceTrivia(node) {
+	return (
+		node?.type === "LeafNode" &&
+		["Token`Whitespace", "Whitespace", "Token`Newline", "Newline"].includes(
+			node.kind,
+		)
+	);
+}
+
+function isComment(node) {
+	return node?.type === "LeafNode" && node.kind === "Token`Comment";
+}

package/src/rules/no-bare-symbol-set.js

@@ -0,0 +1,19 @@
+// src/rules/no-bare-symbol-set.js
+
+export default {
+	name: "no-bare-symbol-set",
+	description:
+		"Global symbol assignment without scoping (x = val at top level)",
+	defaultLevel: "warn",
+
+	visit(node, context) {
+		if (node.type !== "BinaryNode" || node.op !== "Set") return;
+		const lhs = node.children?.[0];
+		if (!lhs) return;
+		if (lhs.type !== "LeafNode" || lhs.kind !== "Symbol") return;
+		context.report({
+			node,
+			message: `"${lhs.value} = ..." is a global assignment. Consider scoping inside Module or With.`,
+		});
+	},
+};

package/src/rules/no-dynamic-module-leak.js

@@ -0,0 +1,74 @@
+// src/rules/no-dynamic-module-leak.js
+
+function getModuleVarNames(varListNode) {
+	const names = new Set();
+	if (!varListNode?.children) return names;
+	for (const c of varListNode.children) {
+		if (c.type === "LeafNode" && c.kind === "Symbol") names.add(c.value);
+		if (c.type === "BinaryNode" && c.op === "Set") {
+			const lhs = c.children?.[0];
+			if (lhs?.type === "LeafNode") names.add(lhs.value);
+		}
+	}
+	return names;
+}
+
+function findSetTargets(node) {
+	const targets = [];
+	walk(node, (n) => {
+		if (n.type === "BinaryNode" && n.op === "Set") {
+			const lhs = n.children?.[0];
+			if (lhs?.type === "LeafNode" && lhs.kind === "Symbol") {
+				targets.push({ name: lhs.value, node: n });
+			}
+		}
+	});
+	return targets;
+}
+
+function walk(node, fn) {
+	if (!node) return;
+	fn(node);
+	node.children?.forEach((c) => walk(c, fn));
+	if (node.head) walk(node.head, fn);
+}
+
+export default {
+	name: "no-dynamic-module-leak",
+	description:
+		"Symbol assigned inside Module body but not declared in var list",
+	defaultLevel: "warn",
+
+	visit(node, context) {
+		if (node.type !== "CallNode") return;
+		if (!["Module", "Block", "DynamicModule"].includes(node.head?.value))
+			return;
+
+		const args =
+			node.children?.filter(
+				(c) =>
+					!(
+						c.type === "LeafNode" &&
+						[
+							"Token`Comma",
+							"Token`Whitespace",
+							"Token`Newline",
+						].includes(c.kind)
+					),
+			) ?? [];
+		if (args.length < 2) return;
+
+		const declared = getModuleVarNames(args[0]);
+		const body = args.slice(1);
+		const setTargets = body.flatMap(findSetTargets);
+
+		for (const { name, node: setNode } of setTargets) {
+			if (!declared.has(name)) {
+				context.report({
+					node: setNode,
+					message: `"${name}" is assigned inside ${node.head.value} but not declared in the variable list — this creates a global side effect.`,
+				});
+			}
+		}
+	},
+};

package/src/rules/no-general-infix-function.js

@@ -0,0 +1,52 @@
+// src/rules/no-general-infix-function.js
+import { normalizeWolframOptions } from "../options.js";
+
+function preservedTildeFunctions(options) {
+	options = normalizeWolframOptions(options);
+	return new Set(
+		String(options?.wolframPreserveTildeInfixFunctions ?? "Join")
+			.split(",")
+			.map((s) => s.trim())
+			.filter(Boolean),
+	);
+}
+
+export default {
+	name: "no-general-infix-function",
+	description:
+		"Prefer fully qualified call syntax over general infix ~f~ form",
+	defaultLevel: "warn",
+	fixableByFormatter: true,
+
+	visit(node, context) {
+		if (node.type !== "TernaryNode" || node.op !== "TernaryTilde") return;
+		const semantic = (node.children ?? []).filter(
+			(c) =>
+				!(
+					c.type === "LeafNode" &&
+					[
+						"Token`Whitespace",
+						"Whitespace",
+						"Token`Newline",
+						"Newline",
+					].includes(c.kind)
+				),
+		);
+		if (semantic.length !== 5) return;
+
+		const fn = semantic[2];
+		if (
+			fn?.type === "LeafNode" &&
+			fn.kind === "Symbol" &&
+			preservedTildeFunctions(context.options).has(fn.value)
+		) {
+			return;
+		}
+
+		const fnName = fn?.value ?? "function";
+		context.report({
+			node,
+			message: `Prefer fully qualified call syntax ${fnName}[x, y] over infix ~${fnName}~ form.`,
+		});
+	},
+};