prettier-plugin-wolfram 0.7.12 → 0.7.13

package/package.json

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

package/src/parser/adapter.js

@@ -1,5 +1,6 @@
 import { makeLineIndex, nodeSource, offsetToLineCol } from "./position.js";
 import { INFIX_OPS, BINARY_OPS, PREFIX_OPS, POSTFIX_OPS, opName } from "./operators.js";
+import { IMPLICIT_NULL_SYMBOL } from "./sentinels.js";
 
 const LEAF_KIND = { symbol: "Symbol", integer: "Integer", real: "Real", string: "String", comment: "Token`Comment" };
 
@@ -47,13 +48,24 @@ export function adapt(tree, source, preprocessedSource, map) {
 
 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;
+	return hasTrailingSemicolon(node, ctx) || spansMultipleLines(node, ctx);
+}
+
+// Returns true if the infix node ends with ";" and has no real RHS. Raw trailing
+// semicolons may be represented as a MISSING node, while preprocessed ones use
+// the internal fake-null symbol.
+function hasTrailingSemicolon(node, ctx) {
+	for (let i = node.childCount - 1; i >= 0; i--) {
+		const child = node.child(i);
+		if (child.isMissing) return true;
+		if (child.isNamed) {
+			if (child.type === "comment") continue;
+			if (isImplicitNullSymbol(child, ctx)) return true;
+			return false;
+		}
+		return child.type === ";";
+	}
+	return false;
 }
 
 function spansMultipleLines(node, ctx) {
@@ -61,6 +73,13 @@ function spansMultipleLines(node, ctx) {
 	return source?.[0]?.[0] !== source?.[1]?.[0];
 }
 
+function isImplicitNullSymbol(node, ctx) {
+	return (
+		node?.type === "symbol" &&
+		ctx.source.slice(node.startIndex, node.endIndex) === IMPLICIT_NULL_SYMBOL
+	);
+}
+
 // 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.
@@ -76,7 +95,7 @@ function collectSemicolonSegments(node, ctx, segments) {
 		if (!c.isNamed) {
 			// ";" operator token
 			semiToken = c;
-		} else if (c.isMissing) {
+		} else if (c.isMissing || isImplicitNullSymbol(c, ctx)) {
 			// trailing implicit null — rhs is nothing (trailing semicolon)
 		} else if (c.type === "comment") {
 			if (lhs === null) leadingComments.push(c);
@@ -138,7 +157,10 @@ function isLeadingCommentForNextSegment(comment, semiToken, ctx) {
 function hoistSemicolonChildren(node, ctx, out) {
 	const segments = [];
 	collectSemicolonSegments(node, ctx, segments);
+	emitSemicolonSegments(segments, ctx, out);
+}
 
+function emitSemicolonSegments(segments, ctx, out) {
 	for (const seg of segments) {
 		for (const c of seg.leadingComments ?? []) out.push(leaf(c, ctx));
 		if (seg.nodes.length === 0) continue;
@@ -195,6 +217,9 @@ function namedChildren(node) {
 }
 
 function leaf(node, ctx, kind = LEAF_KIND[node.type]) {
+	if (isImplicitNullSymbol(node, ctx)) {
+		return { type: "LeafNode", kind: "Token`Fake`ImplicitNull", value: "", source: nodeSource(node, ctx.lineIndex) };
+	}
 	return { type: "LeafNode", kind, value: ctx.source.slice(node.startIndex, node.endIndex), source: nodeSource(node, ctx.lineIndex) };
 }
 

package/src/parser/index.js

@@ -3,6 +3,7 @@ import { dirname, resolve } from "path";
 import { fileURLToPath } from "url";
 import { readFileSync } from "fs";
 import { adapt } from "./adapter.js";
+import { IMPLICIT_NULL_SYMBOL } from "./sentinels.js";
 
 const here = dirname(fileURLToPath(import.meta.url));
 const WASM_PATH = resolve(here, "tree-sitter-wolfram.wasm");
@@ -24,10 +25,11 @@ async function getLanguage() {
 // 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.
+// Length-changing transforms collapse a run of spaces into a single
+// InvisibleTimes char or insert an internal fake Null symbol after terminating
+// semicolons. 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 = "";
 	const map = [];
@@ -37,6 +39,37 @@ export function preprocess(src) {
 		for (let k = start; k < end; k++) map.push(k);
 		result += src.slice(start, end);
 	};
+	const appendSynthetic = (text, originalOffset) => {
+		for (let k = 0; k < text.length; k++) map.push(originalOffset);
+		result += text;
+	};
+	const skipTrivia = (start) => {
+		let j = start;
+		while (j < n) {
+			if (/\s/.test(src[j])) {
+				j++;
+				continue;
+			}
+			if (src[j] === "(" && src[j + 1] === "*") {
+				j += 2;
+				let depth = 1;
+				while (j < n && depth > 0) {
+					if (src[j] === "(" && src[j + 1] === "*") { depth++; j += 2; }
+					else if (src[j] === "*" && src[j + 1] === ")") { depth--; j += 2; }
+					else j++;
+				}
+				continue;
+			}
+			break;
+		}
+		return j;
+	};
+	const isTerminatorBoundary = (offset) =>
+		offset >= n ||
+		src[offset] === "]" ||
+		src[offset] === "}" ||
+		src[offset] === ")" ||
+		(src[offset] === "|" && src[offset + 1] === ">");
 	let i = 0;
 	while (i < n) {
 		// Skip quoted string
@@ -63,6 +96,15 @@ export function preprocess(src) {
 			copyVerbatim(start, i);
 			continue;
 		}
+		if (src[i] === ";" && src[i - 1] !== ";" && src[i + 1] !== ";") {
+			const boundary = skipTrivia(i + 1);
+			if (isTerminatorBoundary(boundary)) {
+				copyVerbatim(i, boundary);
+				appendSynthetic(IMPLICIT_NULL_SYMBOL, boundary);
+				i = boundary;
+				continue;
+			}
+		}
 		// Two or more spaces between word chars on same line → InvisibleTimes
 		if (src[i] === " " && src[i + 1] === " ") {
 			// Check previous meaningful char is a word char

package/src/parser/sentinels.js

@@ -0,0 +1 @@
+export const IMPLICIT_NULL_SYMBOL = "$$PrettierWolframImplicitNull$$";