prettier-plugin-wolfram 0.7.4 → 0.7.6

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "prettier-plugin-wolfram",
-	"version": "0.7.4",
+	"version": "0.7.6",
 	"description": "Prettier plugin for Wolfram Language using tree-sitter",
 	"license": "MIT",
 	"repository": {

package/src/parser/adapter.js

@@ -9,9 +9,12 @@ const GROUP_CLOSE_LEAF = { "}": "Token`CloseCurly", ")": "Token`CloseParen", "]"
 
 // preprocessedSource is the version passed to tree-sitter (may have ⁢ for InvisibleTimes);
 // source is the original — used only for the unformattable fallback.
-export function adapt(tree, source, preprocessedSource) {
+// map (optional) translates preprocessed char offsets back to original offsets;
+// it is attached to lineIndex so nodeSource can record exact original positions.
+export function adapt(tree, source, preprocessedSource, map) {
 	const ps = preprocessedSource ?? source;
 	const lineIndex = makeLineIndex(ps);
+	lineIndex.map = map;
 	const ctx = { source: ps, lineIndex };
 	const root = tree.rootNode;
 	if (subtreeHasError(root)) {
@@ -21,12 +24,14 @@ export function adapt(tree, source, preprocessedSource) {
 		const src = nodeSource(root, errLineIndex);
 		return { type: "ContainerNode", kind: "String", children: [{ type: "Unknown", kind: "SyntaxErrorNode[]", source: src }], source: src };
 	}
-	// Hoist top-level semicolon chains that end with a trailing ";" (MISSING rhs) into separate
-	// ContainerNode children, matching the CodeParser output structure.
-	// Only hoist if the outer infix has a trailing MISSING (i.e. ends with ";").
+	// Hoist top-level semicolon chains into separate ContainerNode children,
+	// matching the CodeParser output structure. This must happen for multiline
+	// chains even when the final expression is not followed by a trailing ";",
+	// otherwise the printer sees one giant CompoundExpression and cannot apply
+	// top-level definition spacing between adjacent definitions.
 	const children = [];
 	for (const c of namedChildren(root)) {
-		if (c.type === "infix" && operatorLiteral(c, ctx) === ";" && hasTrailingSemicolon(c)) {
+		if (shouldHoistTopLevelSemicolonChain(c, ctx)) {
 			hoistSemicolonChildren(c, ctx, children);
 		} else {
 			children.push(adaptNode(c, ctx));
@@ -40,12 +45,22 @@ export function adapt(tree, source, preprocessedSource) {
 	};
 }
 
+function shouldHoistTopLevelSemicolonChain(node, ctx) {
+	if (node.type !== "infix" || operatorLiteral(node, ctx) !== ";") return false;
+	return hasTrailingSemicolon(node) || spansMultipleLines(node, ctx);
+}
+
 // Returns true if the infix node ends with a MISSING node (i.e. has a trailing ";").
 function hasTrailingSemicolon(node) {
 	const last = node.child(node.childCount - 1);
 	return last !== null && last.isMissing;
 }
 
+function spansMultipleLines(node, ctx) {
+	const source = nodeSource(node, ctx.lineIndex);
+	return source?.[0]?.[0] !== source?.[1]?.[0];
+}
+
 // Collect all leaf statements from a semicolon infix chain (possibly left-recursive),
 // flattening the left-associative structure into a linear list of segments.
 // Each segment is { nodes: TSNode[], semiToken: TSNode|null } where semiToken is the ";" that follows.
@@ -53,7 +68,8 @@ function collectSemicolonSegments(node, ctx, segments) {
 	// A semicolon infix has children: [lhs, ";", rhs] or with comments interspersed.
 	// The lhs may itself be a semicolon infix (left-assoc chaining).
 	let lhs = null, semiToken = null, rhs = null;
-	const pendingComments = [];
+	const leadingComments = [];
+	const boundaryComments = [];
 
 	for (let i = 0; i < node.childCount; i++) {
 		const c = node.child(i);
@@ -63,7 +79,8 @@ function collectSemicolonSegments(node, ctx, segments) {
 		} else if (c.isMissing) {
 			// trailing implicit null — rhs is nothing (trailing semicolon)
 		} else if (c.type === "comment") {
-			pendingComments.push(c);
+			if (lhs === null) leadingComments.push(c);
+			else boundaryComments.push(c);
 		} else if (lhs === null) {
 			lhs = c;
 		} else {
@@ -71,31 +88,50 @@ function collectSemicolonSegments(node, ctx, segments) {
 		}
 	}
 
+	const trailingComments = [];
+	const rhsLeadingComments = [];
+	for (const c of boundaryComments) {
+		if (rhs !== null && isLeadingCommentForNextSegment(c, semiToken, ctx)) {
+			rhsLeadingComments.push(c);
+		} else {
+			trailingComments.push(c);
+		}
+	}
+
 	if (lhs !== null && lhs.type === "infix" && operatorLiteral(lhs, ctx) === ";") {
+		const segmentStart = segments.length;
 		// Flatten the left subtree
 		collectSemicolonSegments(lhs, ctx, segments);
+		if (segments.length > segmentStart) {
+			segments[segmentStart].leadingComments.unshift(...leadingComments);
+		}
 		// The last segment from lhs should get the semiToken we found
 		if (segments.length > 0 && semiToken !== null) {
 			segments[segments.length - 1].semiToken = semiToken;
 		}
-		// Add any comments from between lhs and rhs to the last segment's pending
-		for (const c of pendingComments) {
+		for (const c of trailingComments) {
 			if (segments.length > 0) segments[segments.length - 1].trailingComments.push(c);
 		}
 	} else {
 		// Push lhs as a new segment
 		const nodes = [];
 		if (lhs !== null) nodes.push(lhs);
-		segments.push({ nodes, semiToken, trailingComments: [] });
-		for (const c of pendingComments) segments[segments.length - 1].trailingComments.push(c);
+		segments.push({ nodes, semiToken, leadingComments, trailingComments });
 	}
 
 	// Push rhs as the next segment (no semiToken yet — will be set by caller if needed)
 	if (rhs !== null) {
-		segments.push({ nodes: [rhs], semiToken: null, trailingComments: [] });
+		segments.push({ nodes: [rhs], semiToken: null, leadingComments: rhsLeadingComments, trailingComments: [] });
 	}
 }
 
+function isLeadingCommentForNextSegment(comment, semiToken, ctx) {
+	if (!semiToken) return false;
+	const semiEndLine = nodeSource(semiToken, ctx.lineIndex)?.[1]?.[0];
+	const commentStartLine = nodeSource(comment, ctx.lineIndex)?.[0]?.[0];
+	return Number.isFinite(semiEndLine) && Number.isFinite(commentStartLine) && commentStartLine > semiEndLine;
+}
+
 // Hoist top-level semicolon-separated statements into separate ContainerNode children.
 // For `a; b; c;`, produces [CompoundExpr(a;Null), CompoundExpr(b;Null), CompoundExpr(c;Null)].
 // For `a; b`, produces [CompoundExpr(a;Null), b].
@@ -104,6 +140,7 @@ function hoistSemicolonChildren(node, ctx, out) {
 	collectSemicolonSegments(node, ctx, segments);
 
 	for (const seg of segments) {
+		for (const c of seg.leadingComments ?? []) out.push(leaf(c, ctx));
 		if (seg.nodes.length === 0) continue;
 
 		const adaptedNodes = seg.nodes.map(n => adaptNode(n, ctx));

package/src/parser/index.js

@@ -20,10 +20,24 @@ async function getLanguage() {
 
 // Replace space-based implicit multiplication (a  b) with U+2062 (InvisibleTimes)
 // so the grammar can parse it. Skip content inside strings and nested comments.
-export function preprocessInvisibleTimes(src) {
+//
+// Returns { text, map } where `text` is the preprocessed source and `map` is an
+// index translation table: map[i] is the original-source character offset that
+// corresponds to preprocessed-text offset i (map[text.length] === src.length).
+// Because the only length-changing transform collapses a run of spaces into a
+// single InvisibleTimes char, this map lets callers translate tree-sitter node
+// positions (computed on the preprocessed text) back to exact offsets in the
+// original source, without lossy line/col round-trips.
+export function preprocess(src) {
 	let result = "";
-	let i = 0;
+	const map = [];
 	const n = src.length;
+	// Copy src[start..end) verbatim, recording the source offset of each char.
+	const copyVerbatim = (start, end) => {
+		for (let k = start; k < end; k++) map.push(k);
+		result += src.slice(start, end);
+	};
+	let i = 0;
 	while (i < n) {
 		// Skip quoted string
 		if (src[i] === '"') {
@@ -33,7 +47,7 @@ export function preprocessInvisibleTimes(src) {
 				i++;
 			}
 			if (i < n) i++;
-			result += src.slice(start, i);
+			copyVerbatim(start, i);
 			continue;
 		}
 		// Skip nested WL comment (* ... *)
@@ -46,7 +60,7 @@ export function preprocessInvisibleTimes(src) {
 				else if (src[i] === "*" && src[i + 1] === ")") { depth--; i += 2; }
 				else i++;
 			}
-			result += src.slice(start, i);
+			copyVerbatim(start, i);
 			continue;
 		}
 		// Two or more spaces between word chars on same line → InvisibleTimes
@@ -59,14 +73,22 @@ export function preprocessInvisibleTimes(src) {
 				while (j < n && src[j] === " ") j++;
 				if (j < n && /\w/.test(src[j])) {
 					result += "⁢"; // InvisibleTimes, spaces stripped (they're extras)
+					map.push(i); // the single char maps to the start of the run
 					i = j;
 					continue;
 				}
 			}
 		}
+		map.push(i);
 		result += src[i++];
 	}
-	return result;
+	map.push(n); // sentinel for end offsets (node endIndex === text.length)
+	return { text: result, map };
+}
+
+// Backward-compatible wrapper returning only the preprocessed text.
+export function preprocessInvisibleTimes(src) {
+	return preprocess(src).text;
 }
 
 export class WolframParser {
@@ -74,8 +96,8 @@ export class WolframParser {
 		const lang = await getLanguage();
 		const parser = new Parser();
 		parser.setLanguage(lang);
-		const preprocessed = preprocessInvisibleTimes(sourceText);
+		const { text: preprocessed, map } = preprocess(sourceText);
 		const tree = parser.parse(preprocessed);
-		return adapt(tree, sourceText, preprocessed);
+		return adapt(tree, sourceText, preprocessed, map);
 	}
 }

package/src/parser/position.js

@@ -55,8 +55,26 @@ export function offsetToLineCol(lineIndex, charOffset) {
 }
 
 export function nodeSource(tsNode, lineIndex) {
-	return [
+	const source = [
 		offsetToLineCol(lineIndex, tsNode.startIndex),
 		offsetToLineCol(lineIndex, tsNode.endIndex),
 	];
+	// When a preprocessing offset map is available, record the exact original
+	// character offsets (non-enumerably, so node.source stays a [[l,c],[l,c]]
+	// pair for lint rules). These bypass the lossy WL-byte/visual-column line/col
+	// round-trip in addOffsets, which otherwise mismaps offsets whenever the
+	// preprocessed text differs from the original (collapsed spaces, tabs, or
+	// non-ASCII characters earlier on the line).
+	const map = lineIndex?.map;
+	if (map) {
+		const charStart = map[tsNode.startIndex];
+		const charEnd = map[tsNode.endIndex];
+		if (typeof charStart === "number" && typeof charEnd === "number") {
+			Object.defineProperties(source, {
+				charStart: { value: charStart, enumerable: false },
+				charEnd: { value: charEnd, enumerable: false },
+			});
+		}
+	}
+	return source;
 }

package/src/utils/offsets.js

@@ -57,6 +57,14 @@ export function lineColToOffset(table, line, col) {
 
 function sourceToOffsets(source, table) {
 	if (!Array.isArray(source) || source.length !== 2) return null;
+	// Exact original char offsets recorded by the parser (see nodeSource) are
+	// authoritative when present — they avoid the lossy line/col conversion below.
+	if (
+		typeof source.charStart === "number" &&
+		typeof source.charEnd === "number"
+	) {
+		return { locStart: source.charStart, locEnd: source.charEnd };
+	}
 	const [start, end] = source;
 	if (!Array.isArray(start) || !Array.isArray(end)) return null;
 	const [startLine, startCol] = start;