prettier-plugin-wolfram 0.7.0

package/src/utils/codeSpacing.js

@@ -0,0 +1,420 @@
+import { normalizeWolframOptions } from "../options.js";
+
+const DEFAULT_MAX_BLANK_LINES_BETWEEN_CODE = 1;
+const DEFAULT_BLANK_LINES_BETWEEN_DEFINITIONS = 1;
+const DEFAULT_BLANK_LINES_BETWEEN_SAME_NAME_DEFINITIONS = 0;
+
+const SET_DECLARATION_OPS = new Set(["Set", "TagSet", "UpSet"]);
+const SET_DELAYED_DECLARATION_OPS = new Set([
+	"SetDelayed",
+	"TagSetDelayed",
+	"UpSetDelayed",
+]);
+const DECLARATION_OPS = new Set([
+	...SET_DECLARATION_OPS,
+	...SET_DELAYED_DECLARATION_OPS,
+]);
+
+const TRIVIA_KINDS = new Set([
+	"Token`Whitespace",
+	"Whitespace",
+	"Token`Newline",
+	"Newline",
+	"Token`LineContinuation",
+	"LineContinuation",
+	"Token`Fake`ImplicitNull",
+]);
+
+const SEMICOLON_KINDS = new Set(["Token`Semi", "Token`Semicolon"]);
+const SAME_DEFINITION_TARGET_HEADS = new Set(["Options", "Attributes"]);
+const ATTRIBUTE_SETTER_HEADS = new Set(["SetAttributes"]);
+
+export function nonNegativeIntegerOption(value, fallback) {
+	const numeric = Number(value);
+	if (!Number.isFinite(numeric)) return fallback;
+	return Math.max(0, Math.floor(numeric));
+}
+
+export function maxBlankLinesBetweenCode(options = {}) {
+	options = normalizeWolframOptions(options);
+	return nonNegativeIntegerOption(
+		options.wolframMaxBlankLinesBetweenCode,
+		DEFAULT_MAX_BLANK_LINES_BETWEEN_CODE,
+	);
+}
+
+export function blankLinesBetweenDefinitions(options = {}) {
+	options = normalizeWolframOptions(options);
+	return nonNegativeIntegerOption(
+		options.wolframNewlinesBetweenDefinitions,
+		DEFAULT_BLANK_LINES_BETWEEN_DEFINITIONS,
+	);
+}
+
+function optionalBlankLinesOption(value, fallback) {
+	if (value == null) return fallback;
+	return nonNegativeIntegerOption(value, fallback);
+}
+
+export function blankLinesBetweenSetDefinitions(options = {}) {
+	options = normalizeWolframOptions(options);
+	return optionalBlankLinesOption(
+		options.wolframNewlinesBetweenSetDefinitions,
+		blankLinesBetweenDefinitions(options),
+	);
+}
+
+export function blankLinesBetweenSetDelayedDefinitions(options = {}) {
+	options = normalizeWolframOptions(options);
+	return optionalBlankLinesOption(
+		options.wolframNewlinesBetweenSetDelayedDefinitions,
+		blankLinesBetweenDefinitions(options),
+	);
+}
+
+export function blankLinesBetweenSetAndSetDelayedDefinitions(options = {}) {
+	options = normalizeWolframOptions(options);
+	return optionalBlankLinesOption(
+		options.wolframNewlinesBetweenSetAndSetDelayedDefinitions,
+		blankLinesBetweenDefinitions(options),
+	);
+}
+
+export function blankLinesBetweenSameNameDefinitions(options = {}) {
+	options = normalizeWolframOptions(options);
+	return nonNegativeIntegerOption(
+		options.wolframNewlinesBetweenSameNameDefinitions,
+		DEFAULT_BLANK_LINES_BETWEEN_SAME_NAME_DEFINITIONS,
+	);
+}
+
+function isTrivia(node) {
+	return node?.type === "LeafNode" && TRIVIA_KINDS.has(node.kind);
+}
+
+function isSemicolonToken(node) {
+	return node?.type === "LeafNode" && SEMICOLON_KINDS.has(node.kind);
+}
+
+function isComment(node) {
+	return node?.type === "LeafNode" && node.kind === "Token`Comment";
+}
+
+function isToken(node) {
+	return node?.type === "LeafNode" && node.kind?.startsWith("Token`");
+}
+
+function semanticChildren(node) {
+	return (node?.children ?? []).filter(
+		(child) => !isTrivia(child) && !isComment(child) && !isToken(child),
+	);
+}
+
+function isSingleStatementCompound(node) {
+	return (
+		(node?.type === "InfixNode" && node.op === "CompoundExpression") ||
+		(node?.type === "CompoundNode" &&
+			(node.op === "CompoundExpression" || node.op === "Semicolon"))
+	);
+}
+
+export function unwrapSingleStatementNode(node) {
+	if (!isSingleStatementCompound(node)) return node;
+
+	const statements = (node.children ?? []).filter(
+		(child) =>
+			!isTrivia(child) && !isSemicolonToken(child) && !isComment(child),
+	);
+
+	if (statements.length !== 1) return node;
+	return unwrapSingleStatementNode(statements[0]);
+}
+
+export function isDeclarationNode(node) {
+	const statement = unwrapSingleStatementNode(node);
+	return (
+		statement?.type === "BinaryNode" && DECLARATION_OPS.has(statement.op)
+	);
+}
+
+function declarationSpacingKind(node) {
+	const statement = unwrapSingleStatementNode(node);
+	if (statement?.type !== "BinaryNode") return null;
+	if (SET_DECLARATION_OPS.has(statement.op)) return "set";
+	if (SET_DELAYED_DECLARATION_OPS.has(statement.op)) return "setDelayed";
+	return null;
+}
+
+function blankLinesBetweenDeclarationKinds(
+	prevKind,
+	nextKind,
+	options,
+	{ requireSpecificOption = false } = {},
+) {
+	if (prevKind === "set" && nextKind === "set") {
+		if (
+			requireSpecificOption &&
+			options.wolframNewlinesBetweenSetDefinitions == null
+		) {
+			return null;
+		}
+		return blankLinesBetweenSetDefinitions(options);
+	}
+
+	if (prevKind === "setDelayed" && nextKind === "setDelayed") {
+		if (
+			requireSpecificOption &&
+			options.wolframNewlinesBetweenSetDelayedDefinitions == null
+		) {
+			return null;
+		}
+		return blankLinesBetweenSetDelayedDefinitions(options);
+	}
+
+	if (
+		(prevKind === "set" && nextKind === "setDelayed") ||
+		(prevKind === "setDelayed" && nextKind === "set")
+	) {
+		if (
+			requireSpecificOption &&
+			options.wolframNewlinesBetweenSetAndSetDelayedDefinitions == null
+		) {
+			return null;
+		}
+		return blankLinesBetweenSetAndSetDelayedDefinitions(options);
+	}
+
+	return null;
+}
+
+function blankLinesBetweenDeclarationNodes(
+	prevNode,
+	nextNode,
+	options,
+	requireSpecificOption = false,
+) {
+	return blankLinesBetweenDeclarationKinds(
+		declarationSpacingKind(prevNode),
+		declarationSpacingKind(nextNode),
+		options,
+		{ requireSpecificOption },
+	);
+}
+
+function firstSemanticChild(node) {
+	return semanticChildren(node)[0] ?? null;
+}
+
+function symbolName(node) {
+	if (node?.type === "LeafNode" && node.kind === "Symbol") {
+		return String(node.value ?? "");
+	}
+
+	return null;
+}
+
+function callHeadName(node) {
+	return symbolName(node?.head);
+}
+
+function callArgumentNodes(node) {
+	if (node?.type !== "CallNode") return [];
+
+	const commaWrapper = (node.children ?? []).find(
+		(child) => child.type === "InfixNode" && child.op === "Comma",
+	);
+	if (commaWrapper) {
+		return semanticChildren(commaWrapper);
+	}
+
+	return semanticChildren(node);
+}
+
+function subjectNamesFromExpression(node) {
+	const name = symbolName(node);
+	if (name) return new Set([name]);
+
+	if (
+		node?.type === "GroupNode" ||
+		node?.type === "InfixNode" ||
+		node?.type === "CompoundNode"
+	) {
+		const names = new Set();
+		for (const child of semanticChildren(node)) {
+			for (const childName of subjectNamesFromExpression(child)) {
+				names.add(childName);
+			}
+		}
+		return names;
+	}
+
+	return new Set();
+}
+
+function definitionTargetNamesFromCall(node, allowedHeads) {
+	if (node?.type !== "CallNode" || !allowedHeads.has(callHeadName(node))) {
+		return new Set();
+	}
+
+	return subjectNamesFromExpression(callArgumentNodes(node)[0]);
+}
+
+function definitionTargetNamesFromShorthand(node, allowedHeads) {
+	if (node?.type !== "BinaryNode") return new Set();
+
+	const [lhs, rhs] = semanticChildren(node);
+	if (node.op === "BinaryAt" && allowedHeads.has(symbolName(lhs))) {
+		return subjectNamesFromExpression(rhs);
+	}
+
+	if (node.op === "BinarySlashSlash" && allowedHeads.has(symbolName(rhs))) {
+		return subjectNamesFromExpression(lhs);
+	}
+
+	return new Set();
+}
+
+function definitionTargetNames(node, allowedHeads) {
+	const callNames = definitionTargetNamesFromCall(node, allowedHeads);
+	if (callNames.size > 0) return callNames;
+
+	return definitionTargetNamesFromShorthand(node, allowedHeads);
+}
+
+function functionNameFromCallHead(node) {
+	const name = symbolName(node);
+	if (name) return name;
+
+	if (node?.type === "CallNode") {
+		return functionNameFromCallHead(node.head);
+	}
+
+	if (node?.type === "BinaryNode" || node?.type === "CompoundNode") {
+		return functionNameFromCallHead(firstSemanticChild(node));
+	}
+
+	return null;
+}
+
+function functionDefinitionSubjectNamesFromLhs(
+	node,
+	{ allowBareSymbol = false } = {},
+) {
+	const bareName = symbolName(node);
+	if (allowBareSymbol && bareName) return new Set([bareName]);
+
+	if (node?.type === "InfixNode" && node.op === "MessageName") {
+		return subjectNamesFromExpression(firstSemanticChild(node));
+	}
+
+	const targetNames = definitionTargetNames(
+		node,
+		SAME_DEFINITION_TARGET_HEADS,
+	);
+	if (targetNames.size > 0) return targetNames;
+
+	if (node?.type === "BinaryNode") {
+		const [lhs, rhs] = semanticChildren(node);
+		if (node.op === "BinaryAt") {
+			const name = functionNameFromCallHead(lhs);
+			return name ? new Set([name]) : new Set();
+		}
+
+		if (node.op === "BinarySlashSlash") {
+			const name = functionNameFromCallHead(rhs);
+			return name ? new Set([name]) : new Set();
+		}
+	}
+
+	if (node?.type === "CallNode") {
+		const name = functionNameFromCallHead(node.head);
+		return name ? new Set([name]) : new Set();
+	}
+
+	if (node?.type === "BinaryNode" || node?.type === "CompoundNode") {
+		return functionDefinitionSubjectNamesFromLhs(firstSemanticChild(node), {
+			allowBareSymbol,
+		});
+	}
+
+	return new Set();
+}
+
+function binaryLhs(node) {
+	return firstSemanticChild(node);
+}
+
+function definitionSubjectNames(node) {
+	const statement = unwrapSingleStatementNode(node);
+	const attributeNames = definitionTargetNames(
+		statement,
+		ATTRIBUTE_SETTER_HEADS,
+	);
+	if (attributeNames.size > 0) return attributeNames;
+
+	if (
+		statement?.type !== "BinaryNode" ||
+		!DECLARATION_OPS.has(statement.op)
+	) {
+		return new Set();
+	}
+
+	return functionDefinitionSubjectNamesFromLhs(binaryLhs(statement), {
+		allowBareSymbol: ["TagSet", "TagSetDelayed"].includes(statement.op),
+	});
+}
+
+function hasSharedDefinitionSubject(prevNode, nextNode) {
+	const prevNames = definitionSubjectNames(prevNode);
+	if (prevNames.size === 0) return false;
+
+	const nextNames = definitionSubjectNames(nextNode);
+	for (const name of prevNames) {
+		if (nextNames.has(name)) return true;
+	}
+
+	return false;
+}
+
+export function observedBlankLinesBetween(prevEndLine, nextStartLine) {
+	if (!Number.isFinite(prevEndLine) || !Number.isFinite(nextStartLine)) {
+		return 0;
+	}
+
+	return Math.max(0, nextStartLine - prevEndLine - 1);
+}
+
+export function blankLinesForCodeGap(
+	prevNode,
+	nextNode,
+	observedBlankLines,
+	options = {},
+	{ topLevel = false } = {},
+) {
+	options = normalizeWolframOptions(options);
+	const mode = options.wolframTopLevelSpacingMode ?? "declarations";
+	if (topLevel && mode === "none") return 0;
+
+	if (hasSharedDefinitionSubject(prevNode, nextNode)) {
+		return blankLinesBetweenSameNameDefinitions(options);
+	}
+
+	if (isDeclarationNode(prevNode) && isDeclarationNode(nextNode)) {
+		return (
+			blankLinesBetweenDeclarationNodes(prevNode, nextNode, options) ??
+			blankLinesBetweenDefinitions(options)
+		);
+	}
+
+	const maxBlankLines = maxBlankLinesBetweenCode(options);
+	const cappedObserved = Math.min(
+		maxBlankLines,
+		nonNegativeIntegerOption(observedBlankLines, 0),
+	);
+
+	if (topLevel && mode === "all") {
+		return Math.min(maxBlankLines, Math.max(1, cappedObserved));
+	}
+
+	return cappedObserved;
+}

package/src/utils/cstErrors.js

@@ -0,0 +1,36 @@
+const CST_ERROR_SYMBOL_PATTERN =
+	/(?:^|`)(?:AbstractSyntaxErrorNode|SyntaxErrorNode|\w*ErrorNode|\w*Missing\w*Node|\w*Unterminated\w*Node|\w*Incomplete\w*Node|\w*Issue)\[/;
+
+function looksLikeCstErrorSymbol(value) {
+	return typeof value === "string" && CST_ERROR_SYMBOL_PATTERN.test(value);
+}
+
+export function isCstErrorNode(node) {
+	if (!node || typeof node !== "object" || node.type !== "Unknown") {
+		return false;
+	}
+
+	return (
+		looksLikeCstErrorSymbol(node.kind) || looksLikeCstErrorSymbol(node.wl)
+	);
+}
+
+export function containsCstErrors(node) {
+	if (!node || typeof node !== "object") return false;
+	if (isCstErrorNode(node)) return true;
+	if (containsCstErrors(node.head)) return true;
+
+	return (
+		Array.isArray(node.children) && node.children.some(containsCstErrors)
+	);
+}
+
+export function createUnformattableNode(sourceText = "") {
+	return {
+		type: "UnformattableNode",
+		children: [],
+		locStart: 0,
+		locEnd: sourceText.length,
+		wl: sourceText,
+	};
+}

package/src/utils/offsets.js

@@ -0,0 +1,132 @@
+// src/utils/offsets.js
+
+/** Build a table mapping line index (0-based) → character offset of line start */
+export function buildOffsetTable(source, tabWidth = 2) {
+	const table = [0];
+	for (let i = 0; i < source.length; i++) {
+		if (source[i] === "\n") table.push(i + 1);
+	}
+	Object.defineProperties(table, {
+		sourceText: {
+			value: source,
+			enumerable: false,
+		},
+		tabWidth: {
+			value: tabWidth,
+			enumerable: false,
+		},
+	});
+	return table;
+}
+
+/** Convert 1-based line/col to 0-based character offset */
+export function lineColToOffset(table, line, col) {
+	const lineStart = table[line - 1];
+	if (typeof lineStart !== "number") return 0;
+
+	const sourceText =
+		table &&
+		typeof table === "object" &&
+		typeof table.sourceText === "string"
+			? table.sourceText
+			: null;
+	if (!sourceText) return lineStart + (col - 1);
+
+	const width =
+		table && typeof table === "object" && typeof table.tabWidth === "number"
+			? table.tabWidth
+			: 2;
+	let offset = lineStart;
+	let visualCol = 1;
+
+	while (
+		offset < sourceText.length &&
+		sourceText[offset] !== "\n" &&
+		visualCol < col
+	) {
+		if (sourceText[offset] === "\t") {
+			visualCol += width - ((visualCol - 1) % width);
+		} else {
+			visualCol += 1;
+		}
+		offset += 1;
+	}
+
+	return offset;
+}
+
+function sourceToOffsets(source, table) {
+	if (!Array.isArray(source) || source.length !== 2) return null;
+	const [start, end] = source;
+	if (!Array.isArray(start) || !Array.isArray(end)) return null;
+	const [startLine, startCol] = start;
+	const [endLine, endCol] = end;
+	if (
+		[startLine, startCol, endLine, endCol].some(
+			(value) => typeof value !== "number" || Number.isNaN(value),
+		)
+	) {
+		return null;
+	}
+
+	return {
+		locStart: lineColToOffset(table, startLine, startCol),
+		locEnd: lineColToOffset(table, endLine, endCol),
+	};
+}
+
+function nodeOffsets(node) {
+	if (
+		!node ||
+		typeof node !== "object" ||
+		typeof node.locStart !== "number" ||
+		typeof node.locEnd !== "number"
+	) {
+		return null;
+	}
+
+	return { locStart: node.locStart, locEnd: node.locEnd };
+}
+
+function combinedOffsets(nodes) {
+	const ranges = nodes.map(nodeOffsets).filter(Boolean);
+	if (ranges.length === 0) return null;
+
+	return {
+		locStart: Math.min(...ranges.map((range) => range.locStart)),
+		locEnd: Math.max(...ranges.map((range) => range.locEnd)),
+	};
+}
+
+/** Recursively attach locStart/locEnd to every node in the CST tree */
+export function addOffsets(node, table, fallbackOffset = null) {
+	if (!node || typeof node !== "object") return node;
+
+	const ownOffsets = sourceToOffsets(node.source, table);
+	const childFallback =
+		ownOffsets?.locStart ??
+		(typeof fallbackOffset === "number" ? fallbackOffset : null);
+
+	if (node.children) {
+		node.children.forEach((child) =>
+			addOffsets(child, table, childFallback),
+		);
+	}
+	if (node.head) {
+		addOffsets(node.head, table, childFallback);
+	}
+
+	const derivedOffsets =
+		ownOffsets ??
+		combinedOffsets([node.head, ...(node.children ?? [])]) ??
+		(typeof childFallback === "number"
+			? { locStart: childFallback, locEnd: childFallback }
+			: null);
+
+	if (derivedOffsets) {
+		node.locStart = derivedOffsets.locStart;
+		node.locEnd = derivedOffsets.locEnd;
+	}
+
+	return node;
+}

package/src/utils/operatorSpacing.js

@@ -0,0 +1,49 @@
+import { normalizeWolframOptions } from "../options.js";
+
+const TIGHT_INFIX_OPERATORS = new Set(["MessageName"]);
+
+const TIGHT_BINARY_OPERATORS = new Set(["PatternTest", "Span"]);
+
+const TIGHT_TERNARY_OPERATORS = new Set(["Span"]);
+
+const TIGHT_OPERATOR_TOKENS = new Set([
+	"Token`ColonColon",
+	"Token`Question",
+	"Token`SemiSemi",
+]);
+
+const TIGHT_OPERATOR_VALUES = new Set(["::", "?", ";;"]);
+
+export function prefersNoSpacesAroundOperator(node, operatorToken = null) {
+	if (
+		operatorToken &&
+		(TIGHT_OPERATOR_TOKENS.has(operatorToken.kind) ||
+			TIGHT_OPERATOR_VALUES.has(operatorToken.value))
+	) {
+		return true;
+	}
+
+	if (node?.type === "InfixNode") return TIGHT_INFIX_OPERATORS.has(node.op);
+	if (node?.type === "BinaryNode") return TIGHT_BINARY_OPERATORS.has(node.op);
+	if (node?.type === "TernaryNode")
+		return TIGHT_TERNARY_OPERATORS.has(node.op);
+	return false;
+}
+
+export function wantsSpacesAroundOperator(
+	node,
+	options = {},
+	operatorToken = null,
+) {
+	if (prefersNoSpacesAroundOperator(node, operatorToken)) return false;
+	options = normalizeWolframOptions(options);
+	return options?.wolframSpaceAroundOperators ?? true;
+}
+
+export {
+	TIGHT_BINARY_OPERATORS,
+	TIGHT_INFIX_OPERATORS,
+	TIGHT_OPERATOR_TOKENS,
+	TIGHT_OPERATOR_VALUES,
+	TIGHT_TERNARY_OPERATORS,
+};