prettier-plugin-wolfram 0.7.0

package/src/translator/nodes/container.js

@@ -0,0 +1,194 @@
+// src/translator/nodes/container.js
+import { doc } from "prettier";
+const { builders } = doc;
+const { hardline } = builders;
+import {
+	documentationCommentColumn,
+	joinCommentDocs,
+	withAlignedTrailingComment,
+} from "../docComments.js";
+import { commentBoundarySeparator } from "../commentSpacing.js";
+import {
+	blankLinesForCodeGap,
+	observedBlankLinesBetween,
+} from "../../utils/codeSpacing.js";
+import { nodeEndLine, nodeStartLine } from "../sourceLines.js";
+
+function isTrivia(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";
+}
+
+function trailingDocumentationCommentColumns(entries, options) {
+	const columns = new Map();
+	let block = [];
+	let previousEntry = null;
+
+	const flushBlock = () => {
+		if (block.length === 0) return;
+		const column = documentationCommentColumn(block, options);
+		for (const entry of block) {
+			columns.set(entry, column);
+		}
+		block = [];
+	};
+
+	for (const entry of entries) {
+		const observedBlankLines = previousEntry
+			? observedBlankLinesBetween(previousEntry.endLine, entry.startLine)
+			: 0;
+
+		if (
+			!entry.trailingCommentDoc ||
+			entry.leadingComments.length > 0 ||
+			observedBlankLines > 0
+		) {
+			flushBlock();
+		}
+
+		if (entry.trailingCommentDoc) {
+			block.push(entry);
+		}
+
+		previousEntry = entry;
+	}
+
+	flushBlock();
+	return columns;
+}
+
+function containerCommentSeparator(leftNode, rightNode, options) {
+	return commentBoundarySeparator(leftNode, rightNode, options, hardline);
+}
+
+function appendLeadingComments(docs, comments, nextNode, options) {
+	for (let i = 0; i < comments.length; i++) {
+		const comment = comments[i];
+		const followingNode = comments[i + 1]?.node ?? nextNode;
+		docs.push(comment.doc);
+		if (followingNode) {
+			docs.push(
+				containerCommentSeparator(comment.node, followingNode, options),
+			);
+		}
+	}
+}
+
+/** Print a ContainerNode[File, ...] with declaration-aware top-level spacing. */
+export function printContainer(node, options, print) {
+	const children = node.children.filter((c) => !isTrivia(c));
+
+	if (children.length === 0) return "";
+
+	const entries = [];
+	let leadingComments = [];
+	let leadingCommentStartLine = null;
+	let leadingCommentEndLine = null;
+
+	for (const child of children) {
+		if (isComment(child) && entries.length > 0) {
+			const prev = entries[entries.length - 1];
+			const prevEndLine = nodeEndLine(prev.node, options);
+			const commentStartLine = nodeStartLine(child, options);
+			if (
+				prevEndLine &&
+				commentStartLine &&
+				prevEndLine === commentStartLine
+			) {
+				prev.trailingComments.push({ node: child, doc: print(child) });
+				prev.endLine = Math.max(
+					prev.endLine,
+					nodeEndLine(child, options) ?? prev.endLine,
+				);
+				continue;
+			}
+		}
+
+		if (isComment(child)) {
+			leadingComments.push({ node: child, doc: print(child) });
+			leadingCommentStartLine ??= nodeStartLine(child, options);
+			leadingCommentEndLine =
+				nodeEndLine(child, options) ?? leadingCommentEndLine;
+			continue;
+		}
+
+		const childStartLine = nodeStartLine(child, options);
+		const childEndLine = nodeEndLine(child, options) ?? childStartLine ?? 0;
+
+		entries.push({
+			node: child,
+			doc: print(child),
+			leadingComments,
+			trailingComments: [],
+			startLine: leadingCommentStartLine ?? childStartLine ?? 0,
+			endLine: Math.max(
+				childEndLine,
+				leadingCommentEndLine ?? childEndLine,
+			),
+		});
+		leadingComments = [];
+		leadingCommentStartLine = null;
+		leadingCommentEndLine = null;
+	}
+
+	for (const entry of entries) {
+		entry.trailingCommentDoc = joinCommentDocs(
+			entry.trailingComments,
+			options,
+		);
+	}
+
+	const trailingCommentColumns = trailingDocumentationCommentColumns(
+		entries,
+		options,
+	);
+	const docs = [];
+	let previousNode = null;
+
+	for (const entry of entries) {
+		if (docs.length > 0) {
+			const observedBlankLines = observedBlankLinesBetween(
+				previousNode.endLine,
+				entry.startLine,
+			);
+			const blankLines = blankLinesForCodeGap(
+				previousNode.node,
+				entry.node,
+				observedBlankLines,
+				options,
+				{ topLevel: true },
+			);
+			docs.push(hardline, ...Array(blankLines).fill(hardline));
+		}
+
+		if (entry.leadingComments.length > 0) {
+			appendLeadingComments(
+				docs,
+				entry.leadingComments,
+				entry.node,
+				options,
+			);
+		}
+
+		const column =
+			trailingCommentColumns.get(entry) ??
+			documentationCommentColumn([entry], options);
+		docs.push(withAlignedTrailingComment(entry, options, column));
+		previousNode = entry;
+	}
+
+	if (leadingComments.length > 0) {
+		if (docs.length > 0) docs.push(hardline);
+		appendLeadingComments(docs, leadingComments, null, options);
+	}
+
+	return docs;
+}

package/src/translator/nodes/group.js

@@ -0,0 +1,159 @@
+// src/translator/nodes/group.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 GROUP_DELIMITERS = {
+	GroupSquare: ["[", "]"],
+	GroupCurly: ["{", "}"],
+	GroupParen: ["(", ")"],
+	GroupDoubleBracket: ["[[", "]]"],
+	List: ["{", "}"],
+	Association: ["<|", "|>"],
+};
+
+const BRACKET_KINDS = new Set([
+	"Token`OpenCurly",
+	"Token`CloseCurly",
+	"Token`OpenSquare",
+	"Token`CloseSquare",
+	"Token`OpenParen",
+	"Token`CloseParen",
+	"Token`LessBar",
+	"Token`BarGreater",
+]);
+
+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,
+	);
+}
+
+function sequenceEntries(path, print, node) {
+	const contents = node.children.filter(
+		(child) => !isTrivia(child) && !isBracketToken(child),
+	);
+
+	if (
+		contents.length === 1 &&
+		contents[0].type === "InfixNode" &&
+		contents[0].op === "Comma"
+	) {
+		const wrapperIdx = node.children.indexOf(contents[0]);
+		return contents[0].children.reduce((entries, child, idx) => {
+			if (isTrivia(child)) return entries;
+			entries.push({
+				node: child,
+				doc: path.call(print, "children", wrapperIdx, "children", idx),
+				path: ["children", wrapperIdx, "children", idx],
+			});
+			return entries;
+		}, []);
+	}
+
+	return node.children.reduce((entries, child, idx) => {
+		if (isTrivia(child) || isBracketToken(child)) return entries;
+		entries.push({
+			node: child,
+			doc: path.call(print, "children", idx),
+			path: ["children", idx],
+		});
+		return entries;
+	}, []);
+}
+
+export function printGroup(path, options, print, node) {
+	options = normalizeWolframOptions(options);
+	const [open, close] = GROUP_DELIMITERS[node.kind] ?? ["{", "}"];
+	const entries = withAlignedRuleValues(
+		sequenceEntries(path, print, node),
+		path,
+		options,
+		print,
+	);
+
+	if (entries.length === 0) return `${open}${close}`;
+
+	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" : "item";
+	}
+
+	if (docs.length === 0) return `${open}${close}`;
+
+	const contents = [open, indent([softline, ...docs]), softline, close];
+
+	return alignmentGroupId
+		? group(contents, { id: alignmentGroupId })
+		: group(contents);
+}