prettier-plugin-wolfram 0.7.0

package/src/translator/nodes/binary.js

@@ -0,0 +1,205 @@
+// src/translator/nodes/binary.js
+import { doc } from "prettier";
+const { builders } = doc;
+import { isTrivia } from "./leaf.js";
+import { argPathEntries } from "./call.js";
+import { wantsSpacesAroundOperator } from "../../utils/operatorSpacing.js";
+import {
+	hasImmediateComment,
+	printOriginalSource,
+} from "../sourcePreservation.js";
+const { group, indent, line, softline } = builders;
+const { willBreak } = doc.utils;
+
+const OP_DISPLAY = {
+	Set: "=",
+	SetDelayed: ":=",
+	Power: "^",
+	ReplaceAll: "/.",
+	Divide: "/",
+	Map: "/@",
+	Apply: "@@",
+	MapApply: "@@@",
+	MapAll: "//@",
+	BinaryAt: "@",
+	BinarySlashSlash: "//",
+	Rule: "->",
+	RuleDelayed: ":>",
+	TagSet: "/: =",
+	TagSetDelayed: "/: :=",
+	UpSet: "^=",
+	UpSetDelayed: "^:=",
+	PatternTest: "?",
+	Condition: "/;",
+	MessageName: "::",
+};
+
+function isSemanticTokenLeaf(node) {
+	return (
+		node?.type === "LeafNode" &&
+		[
+			"Token`Hash",
+			"Token`HashHash",
+			"Token`Under",
+			"Token`UnderUnder",
+			"Token`UnderUnderUnder",
+		].includes(node.kind)
+	);
+}
+
+function isFakeTokenLeaf(node) {
+	return node?.type === "LeafNode" && node.kind.startsWith("Token`Fake`");
+}
+
+function isOperatorTokenLeaf(node) {
+	return (
+		node?.type === "LeafNode" &&
+		node.kind.startsWith("Token`") &&
+		!isSemanticTokenLeaf(node) &&
+		!isFakeTokenLeaf(node)
+	);
+}
+
+function lhsRhs(node) {
+	const semantic = node.children.filter(
+		(c) =>
+			!isTrivia(c) &&
+			!(
+				c.type === "LeafNode" &&
+				c.kind.startsWith("Token`") &&
+				!isSemanticTokenLeaf(c)
+			),
+	);
+	return [semantic[0], semantic[1]];
+}
+
+function operatorToken(node) {
+	const tokens = node.children.filter(
+		(c) => !isTrivia(c) && isOperatorTokenLeaf(c),
+	);
+	return tokens.length === 1 ? tokens[0] : null;
+}
+
+function printSpan(node, print) {
+	const semantic = node.children.filter((c) => !isTrivia(c));
+	const tokenIndex = semantic.findIndex(
+		(c) => isOperatorTokenLeaf(c) && c.value === ";;",
+	);
+	if (tokenIndex === -1) return null;
+	const lhs = semantic
+		.slice(0, tokenIndex)
+		.find((c) => !isOperatorTokenLeaf(c));
+	const rhs = semantic
+		.slice(tokenIndex + 1)
+		.find((c) => !isOperatorTokenLeaf(c));
+
+	return group([
+		lhs && !isFakeTokenLeaf(lhs) ? print(lhs) : "",
+		";;",
+		rhs && !isFakeTokenLeaf(rhs) ? print(rhs) : "",
+	]);
+}
+
+function isMultilineStringJoin(node) {
+	if (node?.type === "InfixNode" && node.op === "StringJoin") {
+		return true;
+	}
+
+	if (
+		node?.type !== "CallNode" ||
+		node.head?.type !== "LeafNode" ||
+		node.head.kind !== "Symbol" ||
+		node.head.value !== "StringJoin"
+	) {
+		return false;
+	}
+
+	return (
+		argPathEntries(node).filter(
+			(entry) =>
+				!(
+					entry.node?.type === "LeafNode" &&
+					entry.node.kind === "Token`Comma"
+				),
+		).length > 1
+	);
+}
+
+function isMultilineStringLeaf(node, printedDoc) {
+	return (
+		node?.type === "LeafNode" &&
+		node.kind === "String" &&
+		willBreak(printedDoc)
+	);
+}
+
+/** A right-hand side that delimits itself with brackets (a call like f[...] or
+ *  a group like {...}, <|...|>, (...)) already dedents its own closing token,
+ *  so its broken layout is correct as-is. Other values (infix chains, etc.)
+ *  need their continuation lines indented one level under the operator. */
+function rhsManagesOwnIndent(node) {
+	return node?.type === "CallNode" || node?.type === "GroupNode";
+}
+
+export function printBinary(node, options, print) {
+	if (hasImmediateComment(node)) {
+		return printOriginalSource(node, options);
+	}
+
+	if (node.op === "Span") {
+		return printSpan(node, print) ?? printOriginalSource(node, options);
+	}
+
+	const token = operatorToken(node);
+	const opStr = token?.value ?? OP_DISPLAY[node.op] ?? node.op;
+	const space = wantsSpacesAroundOperator(node, options, token);
+	const [lhs, rhs] = lhsRhs(node);
+	if (!lhs || !rhs) {
+		return printOriginalSource(node, options);
+	}
+	const gap = space ? " " : "";
+	const lhsDoc = print(lhs);
+	const rhsDoc = print(rhs);
+	const rhsWillBreak =
+		isMultilineStringLeaf(rhs, rhsDoc) || isMultilineStringJoin(rhs);
+
+	if (node.op === "BinaryAt" || node.op === "BinarySlashSlash") {
+		return group([
+			lhsDoc,
+			`${gap}${opStr}`,
+			space ? line : softline,
+			rhsDoc,
+		]);
+	}
+
+	if (!space) {
+		if (rhsWillBreak) {
+			return group([lhsDoc, opStr, indent([line, rhsDoc])]);
+		}
+
+		return group([lhsDoc, opStr, rhsDoc]);
+	}
+
+	if (
+		[
+			"Power",
+			"Divide",
+			"ReplaceAll",
+			"Rule",
+			"RuleDelayed",
+			"Map",
+			"Apply",
+			"MapApply",
+			"MapAll",
+		].includes(node.op)
+	) {
+		if (rhsWillBreak) {
+			return group([lhsDoc, `${gap}${opStr}`, indent([line, rhsDoc])]);
+		}
+
+		const value = rhsManagesOwnIndent(rhs) ? rhsDoc : indent(rhsDoc);
+		return group([lhsDoc, `${gap}${opStr}${gap}`, value]);
+	}
+
+	return group([lhsDoc, `${gap}${opStr}`, indent([line, rhsDoc])]);
+}

package/src/translator/nodes/call.js

@@ -0,0 +1,254 @@
+// src/translator/nodes/call.js
+import { doc } from "prettier";
+const { builders } = doc;
+import { isComment, isTrivia } from "./leaf.js";
+import { alignedRuleDoc, withAlignedRuleValues } from "../ruleAlignment.js";
+import { commentBoundarySeparator } from "../commentSpacing.js";
+import { normalizeWolframOptions } from "../../options.js";
+const { group, indent, softline, line } = builders;
+
+const BRACKET_KINDS = new Set(["Token`OpenSquare", "Token`CloseSquare"]);
+
+function isBracketToken(node) {
+	return node.type === "LeafNode" && BRACKET_KINDS.has(node.kind);
+}
+
+function isCommaToken(node) {
+	return node.type === "LeafNode" && node.kind === "Token`Comma";
+}
+
+function nextContentEntry(entries, startIndex) {
+	for (let i = startIndex + 1; i < entries.length; i++) {
+		if (!isCommaToken(entries[i].node)) return entries[i];
+	}
+	return null;
+}
+
+function previousContentEntry(entries, startIndex) {
+	for (let i = startIndex - 1; i >= 0; i--) {
+		if (!isCommaToken(entries[i].node)) return entries[i];
+	}
+	return null;
+}
+
+function hasCommentBoundary(leftEntry, rightEntry) {
+	return isComment(leftEntry?.node) || isComment(rightEntry?.node);
+}
+
+function commentBoundary(leftEntry, rightEntry, options, fallback = line) {
+	if (!leftEntry || !rightEntry) return fallback;
+	return commentBoundarySeparator(
+		leftEntry.node,
+		rightEntry.node,
+		options,
+		fallback,
+	);
+}
+
+/** Find index of the InfixNode[Comma] wrapper in node.children, or -1. */
+function commaWrapperIndex(node) {
+	return node.children.findIndex(
+		(c) => c.type === "InfixNode" && c.op === "Comma",
+	);
+}
+
+function rawArgEntries(node) {
+	const wrapperIdx = commaWrapperIndex(node);
+
+	return node.children.reduce((entries, child, idx) => {
+		if (isTrivia(child) || isBracketToken(child)) return entries;
+
+		if (idx === wrapperIdx) {
+			child.children.forEach((wrappedChild, wrappedIdx) => {
+				if (isTrivia(wrappedChild)) return;
+				entries.push({
+					node: wrappedChild,
+					path: ["children", idx, "children", wrappedIdx],
+				});
+			});
+			return entries;
+		}
+
+		entries.push({
+			node: child,
+			path: ["children", idx],
+		});
+		return entries;
+	}, []);
+}
+
+export function argPathEntries(node) {
+	return rawArgEntries(node);
+}
+
+export function hasDirectCommentArg(node) {
+	return argPathEntries(node).some((entry) => isComment(entry.node));
+}
+
+export function printedArgEntries(path, options, print, node) {
+	return argPathEntries(node).map((entry) => ({
+		node: entry.node,
+		doc: path.call(print, ...entry.path),
+		path: entry.path,
+	}));
+}
+
+/** Extract semantic argument nodes from a CallNode, and return them along
+ *  with a path-aware print function for each.
+ *
+ *  path/print are prettier primitives so we can descend correctly into nested
+ *  nodes (avoiding indexOf returning -1 for nodes that aren't direct children).
+ */
+export function printedArgs(path, options, print, node) {
+	return printedArgEntries(path, options, print, node)
+		.filter((entry) => !isCommaToken(entry.node))
+		.map((entry) => entry.doc);
+}
+
+function partGroupEntry(node) {
+	const entries = rawArgEntries(node).filter(
+		(entry) => !isCommaToken(entry.node),
+	);
+	if (entries.length !== 1) return null;
+	const [entry] = entries;
+	return entry.node.type === "GroupNode" && entry.node.kind === "GroupSquare"
+		? entry
+		: null;
+}
+
+function groupPathEntries(groupNode, groupPath) {
+	const contents = groupNode.children.filter(
+		(child) => !isTrivia(child) && !isBracketToken(child),
+	);
+
+	if (
+		contents.length === 1 &&
+		contents[0].type === "InfixNode" &&
+		contents[0].op === "Comma"
+	) {
+		const wrapperIdx = groupNode.children.indexOf(contents[0]);
+		return contents[0].children.reduce((entries, child, idx) => {
+			if (isTrivia(child)) return entries;
+			entries.push({
+				node: child,
+				path: [...groupPath, "children", wrapperIdx, "children", idx],
+			});
+			return entries;
+		}, []);
+	}
+
+	return groupNode.children.reduce((entries, child, idx) => {
+		if (isTrivia(child) || isBracketToken(child)) return entries;
+		entries.push({
+			node: child,
+			path: [...groupPath, "children", idx],
+		});
+		return entries;
+	}, []);
+}
+
+function printedEntries(path, print, entries) {
+	return entries.map((entry) => ({
+		node: entry.node,
+		doc: path.call(print, ...entry.path),
+		path: entry.path,
+	}));
+}
+
+function sequenceDocs(entries, options, itemKind) {
+	const docs = [];
+	const commaGap = options.wolframSpaceAfterComma ? line : softline;
+	const alignmentGroupId = entries.some((entry) => entry.alignedRuleDoc)
+		? Symbol("wolfram-align-rule-values")
+		: null;
+	let previousKind = null;
+
+	for (let i = 0; i < entries.length; i++) {
+		const entry = entries[i];
+		if (isCommaToken(entry.node)) {
+			if (previousKind === null || previousKind === "comma") continue;
+			const previousEntry = previousContentEntry(entries, i);
+			const followingEntry = nextContentEntry(entries, i);
+			const separator =
+				followingEntry &&
+				hasCommentBoundary(previousEntry, followingEntry)
+					? commentBoundary(
+							previousEntry,
+							followingEntry,
+							options,
+							commaGap,
+						)
+					: commaGap;
+			docs.push(",", separator);
+			previousKind = "comma";
+			continue;
+		}
+
+		if (previousKind !== null && previousKind !== "comma") {
+			const previousEntry = previousContentEntry(entries, i);
+			docs.push(
+				hasCommentBoundary(previousEntry, entry)
+					? commentBoundary(previousEntry, entry, options, line)
+					: line,
+			);
+		}
+
+		docs.push(alignedRuleDoc(entry, alignmentGroupId));
+		previousKind = isComment(entry.node) ? "comment" : itemKind;
+	}
+
+	return { docs, alignmentGroupId };
+}
+
+function grouped(contents, alignmentGroupId) {
+	return alignmentGroupId
+		? group(contents, { id: alignmentGroupId })
+		: group(contents);
+}
+
+function printPartCall(path, options, print, node, head) {
+	const partEntry = partGroupEntry(node);
+	if (!partEntry) return null;
+
+	const entries = withAlignedRuleValues(
+		printedEntries(
+			path,
+			print,
+			groupPathEntries(partEntry.node, partEntry.path),
+		),
+		path,
+		options,
+		print,
+	);
+	const args = entries.filter((entry) => !isCommaToken(entry.node));
+
+	if (args.length === 0) return [head, "[[]]"];
+
+	const { docs, alignmentGroupId } = sequenceDocs(entries, options, "part");
+	return grouped(
+		[head, "[[", indent([softline, ...docs]), softline, "]]"],
+		alignmentGroupId,
+	);
+}
+
+export function printCall(path, options, print, node) {
+	options = normalizeWolframOptions(options);
+	const head = path.call(print, "head");
+	const partCall = printPartCall(path, options, print, node, head);
+	if (partCall) return partCall;
+
+	const entries = withAlignedRuleValues(
+		printedArgEntries(path, options, print, node),
+		path,
+		options,
+		print,
+	);
+	const args = entries.filter((entry) => !isCommaToken(entry.node));
+
+	if (args.length === 0) return [head, "[]"];
+
+	const { docs, alignmentGroupId } = sequenceDocs(entries, options, "arg");
+	const contents = [head, "[", indent([softline, ...docs]), softline, "]"];
+
+	return grouped(contents, alignmentGroupId);
+}

package/src/translator/nodes/compound.js

@@ -0,0 +1,117 @@
+// src/translator/nodes/compound.js
+import { doc } from "prettier";
+const { builders } = doc;
+import { isTrivia, isComment } from "./leaf.js";
+import { joinCommentDocs } from "../docComments.js";
+import {
+	blankLinesForCodeGap,
+	observedBlankLinesBetween,
+} from "../../utils/codeSpacing.js";
+const { group, hardline } = builders;
+
+const PATTERN_BLANK_OPS = new Set([
+	"PatternBlank",
+	"PatternBlankSequence",
+	"PatternBlankNullSequence",
+]);
+
+const BLANK_OPS = new Set(["Blank", "BlankSequence", "BlankNullSequence"]);
+
+function isSemicolonToken(node) {
+	return (
+		node?.type === "LeafNode" &&
+		(node.kind === "Token`Semi" || node.kind === "Token`Semicolon")
+	);
+}
+
+function hasTrailingSemicolon(children) {
+	for (let i = children.length - 1; i >= 0; i--) {
+		const child = children[i];
+		if (isTrivia(child) || isComment(child)) continue;
+		return isSemicolonToken(child);
+	}
+	return false;
+}
+
+function printBlankCompound(node, print) {
+	const semantic = node.children.filter((c) => !isTrivia(c));
+	if (semantic.length === 0) return "";
+	return group(semantic.map((child) => print(child)));
+}
+
+export function printCompound(node, options, print) {
+	if (PATTERN_BLANK_OPS.has(node.op)) {
+		return printBlankCompound(node, print);
+	}
+
+	if (BLANK_OPS.has(node.op)) {
+		return printBlankCompound(node, print);
+	}
+
+	if (node.op === "Pattern") {
+		const semantic = node.children.filter((c) => !isTrivia(c));
+		if (semantic.length === 2)
+			return [print(semantic[0]), ":", print(semantic[1])];
+	}
+
+	if (node.op === "Slot" || node.op === "SlotSequence") {
+		return node.children.filter((c) => !isTrivia(c)).map((c) => print(c));
+	}
+
+	// CompoundNode[Semicolon, {a, ws, ;, ws, b, ...}]
+	const stmts = node.children.filter(
+		(c) => !isTrivia(c) && !isComment(c) && !isSemicolonToken(c),
+	);
+	const trailingComments = node.children.filter((c) => isComment(c));
+	const trailingSemicolon = hasTrailingSemicolon(node.children);
+
+	if (stmts.length === 1) {
+		return trailingComments.length === 0
+			? [print(stmts[0]), ";"]
+			: [
+					print(stmts[0]),
+					"; ",
+					joinCommentDocs(
+						trailingComments.map((node) => ({
+							node,
+							doc: print(node),
+						})),
+						options,
+					),
+				];
+	}
+
+	const body = [];
+	let previousStmt = null;
+
+	for (const stmt of stmts) {
+		if (previousStmt) {
+			const observedBlankLines = observedBlankLinesBetween(
+				previousStmt.source?.[1]?.[0],
+				stmt.source?.[0]?.[0],
+			);
+			const blankLines = blankLinesForCodeGap(
+				previousStmt,
+				stmt,
+				observedBlankLines,
+				options,
+			);
+			body.push(";", hardline, ...Array(blankLines).fill(hardline));
+		}
+
+		body.push(print(stmt));
+		previousStmt = stmt;
+	}
+
+	if (trailingSemicolon) body.push(";");
+
+	if (trailingComments.length === 0) return body;
+	return [
+		body,
+		" ",
+		joinCommentDocs(
+			trailingComments.map((node) => ({ node, doc: print(node) })),
+			options,
+		),
+	];
+}