prettier-plugin-wolfram 0.7.12 → 0.7.14

package/package.json

@@ -1,11 +1,15 @@
 {
 	"name": "prettier-plugin-wolfram",
-	"version": "0.7.12",
+	"version": "0.7.14",
 	"description": "Prettier plugin for Wolfram Language using tree-sitter",
 	"license": "MIT",
 	"repository": {
 		"type": "git",
-		"url": "git://github.com/ToneAr/prettier-plugin-wolfram.git"
+		"url": "https://github.com/ToneAr/prettier-plugin-wolfram.git"
+	},
+	"homepage": "https://github.com/ToneAr/prettier-plugin-wolfram#readme",
+	"bugs": {
+		"url": "https://github.com/ToneAr/prettier-plugin-wolfram/issues"
 	},
 	"keywords": [
 		"prettier",
@@ -55,8 +59,5 @@
 	},
 	"workspaces": [
 		"vscode-extension"
-	],
-	"engines": {
-		"vscode": "^1.105.0"
-	}
+	]
 }

package/src/options.js

@@ -15,6 +15,9 @@ function wolframOptionDefinition(definition) {
 	return {
 		type: definition.type,
 		category: "Wolfram",
+		...(hasOwn(definition, "exception")
+			? { exception: definition.exception }
+			: {}),
 		...(hasOwn(definition, "default")
 			? { default: definition.default }
 			: {}),
@@ -22,42 +25,61 @@ function wolframOptionDefinition(definition) {
 	};
 }
 
+function isBlankLineRange(value) {
+	return (
+		isPlainObject(value) &&
+		Number.isInteger(value.min) &&
+		Number.isInteger(value.max) &&
+		value.min >= 0 &&
+		value.max >= value.min
+	);
+}
+
+function blankLineRangeOption(defaultValue, description) {
+	return {
+		type: "int",
+		...(defaultValue == null ? {} : { default: defaultValue }),
+		exception: (value) =>
+			(Number.isInteger(value) && value >= 0) || isBlankLineRange(value),
+		description,
+	};
+}
+
 export const wolframOptions = {
 	newlinesBetweenDefinitions: {
-		type: "int",
-		default: 1,
-		minimum: 0,
+		...blankLineRangeOption(
+			{ min: 1, max: 1 },
+			"Allowed blank lines between adjacent definitions.",
+		),
 		legacyName: "wolframNewlinesBetweenDefinitions",
-		description: "Blank lines inserted between adjacent definitions.",
 	},
 	newlinesBetweenSetDefinitions: {
-		type: "int",
-		minimum: 0,
+		...blankLineRangeOption(
+			null,
+			"Allowed blank lines between adjacent Set-family definitions. Inherits newlinesBetweenDefinitions when unset.",
+		),
 		legacyName: "wolframNewlinesBetweenSetDefinitions",
-		description:
-			"Blank lines inserted between adjacent Set-family definitions. Inherits newlinesBetweenDefinitions when unset.",
 	},
 	newlinesBetweenSetDelayedDefinitions: {
-		type: "int",
-		minimum: 0,
+		...blankLineRangeOption(
+			null,
+			"Allowed blank lines between adjacent SetDelayed-family definitions. Inherits newlinesBetweenDefinitions when unset.",
+		),
 		legacyName: "wolframNewlinesBetweenSetDelayedDefinitions",
-		description:
-			"Blank lines inserted between adjacent SetDelayed-family definitions. Inherits newlinesBetweenDefinitions when unset.",
 	},
 	newlinesBetweenSetAndSetDelayedDefinitions: {
-		type: "int",
-		minimum: 0,
+		...blankLineRangeOption(
+			null,
+			"Allowed blank lines between mixed Set-family and SetDelayed-family definitions. Inherits newlinesBetweenDefinitions when unset.",
+		),
 		legacyName: "wolframNewlinesBetweenSetAndSetDelayedDefinitions",
-		description:
-			"Blank lines inserted between mixed Set-family and SetDelayed-family definitions. Inherits newlinesBetweenDefinitions when unset.",
 	},
 	newlinesBetweenSameNameDefinitions: {
-		type: "int",
-		default: 0,
-		minimum: 0,
+		...blankLineRangeOption(
+			{ min: 0, max: 0 },
+			"Allowed blank lines between adjacent definitions that belong to the same symbol.",
+		),
 		legacyName: "wolframNewlinesBetweenSameNameDefinitions",
-		description:
-			"Blank lines inserted between adjacent definitions that belong to the same symbol.",
 	},
 	maxBlankLinesBetweenCode: {
 		type: "int",

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$$";

package/src/utils/codeSpacing.js

@@ -35,6 +35,27 @@ export function nonNegativeIntegerOption(value, fallback) {
 	return Math.max(0, Math.floor(numeric));
 }
 
+function blankLineRangeOption(value, fallback) {
+	if (value == null) return fallback;
+	if (typeof value === "object" && !Array.isArray(value)) {
+		const min = nonNegativeIntegerOption(value.min, fallback.min);
+		const max = nonNegativeIntegerOption(value.max, fallback.max);
+		return { min, max: Math.max(min, max) };
+	}
+
+	const exact = nonNegativeIntegerOption(value, fallback.min);
+	return { min: exact, max: exact };
+}
+
+function exactBlankLineRange(value) {
+	return { min: value, max: value };
+}
+
+function blankLinesFromRange(observedBlankLines, range) {
+	const observed = nonNegativeIntegerOption(observedBlankLines, 0);
+	return Math.min(range.max, Math.max(range.min, observed));
+}
+
 export function maxBlankLinesBetweenCode(options = {}) {
 	options = normalizeWolframOptions(options);
 	return nonNegativeIntegerOption(
@@ -44,47 +65,72 @@ export function maxBlankLinesBetweenCode(options = {}) {
 }
 
 export function blankLinesBetweenDefinitions(options = {}) {
+	const range = blankLineRangeBetweenDefinitions(options);
+	return range.min;
+}
+
+function blankLineRangeBetweenDefinitions(options = {}) {
 	options = normalizeWolframOptions(options);
-	return nonNegativeIntegerOption(
+	return blankLineRangeOption(
 		options.wolframNewlinesBetweenDefinitions,
-		DEFAULT_BLANK_LINES_BETWEEN_DEFINITIONS,
+		exactBlankLineRange(DEFAULT_BLANK_LINES_BETWEEN_DEFINITIONS),
 	);
 }
 
-function optionalBlankLinesOption(value, fallback) {
+function optionalBlankLineRangeOption(value, fallback) {
 	if (value == null) return fallback;
-	return nonNegativeIntegerOption(value, fallback);
+	return blankLineRangeOption(value, fallback);
 }
 
 export function blankLinesBetweenSetDefinitions(options = {}) {
+	const range = blankLineRangeBetweenSetDefinitions(options);
+	return range.min;
+}
+
+function blankLineRangeBetweenSetDefinitions(options = {}) {
 	options = normalizeWolframOptions(options);
-	return optionalBlankLinesOption(
+	return optionalBlankLineRangeOption(
 		options.wolframNewlinesBetweenSetDefinitions,
-		blankLinesBetweenDefinitions(options),
+		blankLineRangeBetweenDefinitions(options),
 	);
 }
 
 export function blankLinesBetweenSetDelayedDefinitions(options = {}) {
+	const range = blankLineRangeBetweenSetDelayedDefinitions(options);
+	return range.min;
+}
+
+function blankLineRangeBetweenSetDelayedDefinitions(options = {}) {
 	options = normalizeWolframOptions(options);
-	return optionalBlankLinesOption(
+	return optionalBlankLineRangeOption(
 		options.wolframNewlinesBetweenSetDelayedDefinitions,
-		blankLinesBetweenDefinitions(options),
+		blankLineRangeBetweenDefinitions(options),
 	);
 }
 
 export function blankLinesBetweenSetAndSetDelayedDefinitions(options = {}) {
+	const range = blankLineRangeBetweenSetAndSetDelayedDefinitions(options);
+	return range.min;
+}
+
+function blankLineRangeBetweenSetAndSetDelayedDefinitions(options = {}) {
 	options = normalizeWolframOptions(options);
-	return optionalBlankLinesOption(
+	return optionalBlankLineRangeOption(
 		options.wolframNewlinesBetweenSetAndSetDelayedDefinitions,
-		blankLinesBetweenDefinitions(options),
+		blankLineRangeBetweenDefinitions(options),
 	);
 }
 
 export function blankLinesBetweenSameNameDefinitions(options = {}) {
+	const range = blankLineRangeBetweenSameNameDefinitions(options);
+	return range.min;
+}
+
+function blankLineRangeBetweenSameNameDefinitions(options = {}) {
 	options = normalizeWolframOptions(options);
-	return nonNegativeIntegerOption(
+	return blankLineRangeOption(
 		options.wolframNewlinesBetweenSameNameDefinitions,
-		DEFAULT_BLANK_LINES_BETWEEN_SAME_NAME_DEFINITIONS,
+		exactBlankLineRange(DEFAULT_BLANK_LINES_BETWEEN_SAME_NAME_DEFINITIONS),
 	);
 }
 
@@ -187,6 +233,48 @@ function blankLinesBetweenDeclarationKinds(
 	return null;
 }
 
+function blankLineRangeBetweenDeclarationKinds(
+	prevKind,
+	nextKind,
+	options,
+	{ requireSpecificOption = false } = {},
+) {
+	if (prevKind === "set" && nextKind === "set") {
+		if (
+			requireSpecificOption &&
+			options.wolframNewlinesBetweenSetDefinitions == null
+		) {
+			return null;
+		}
+		return blankLineRangeBetweenSetDefinitions(options);
+	}
+
+	if (prevKind === "setDelayed" && nextKind === "setDelayed") {
+		if (
+			requireSpecificOption &&
+			options.wolframNewlinesBetweenSetDelayedDefinitions == null
+		) {
+			return null;
+		}
+		return blankLineRangeBetweenSetDelayedDefinitions(options);
+	}
+
+	if (
+		(prevKind === "set" && nextKind === "setDelayed") ||
+		(prevKind === "setDelayed" && nextKind === "set")
+	) {
+		if (
+			requireSpecificOption &&
+			options.wolframNewlinesBetweenSetAndSetDelayedDefinitions == null
+		) {
+			return null;
+		}
+		return blankLineRangeBetweenSetAndSetDelayedDefinitions(options);
+	}
+
+	return null;
+}
+
 function blankLinesBetweenDeclarationNodes(
 	prevNode,
 	nextNode,
@@ -201,6 +289,20 @@ function blankLinesBetweenDeclarationNodes(
 	);
 }
 
+function blankLineRangeBetweenDeclarationNodes(
+	prevNode,
+	nextNode,
+	options,
+	requireSpecificOption = false,
+) {
+	return blankLineRangeBetweenDeclarationKinds(
+		declarationSpacingKind(prevNode),
+		declarationSpacingKind(nextNode),
+		options,
+		{ requireSpecificOption },
+	);
+}
+
 function firstSemanticChild(node) {
 	return semanticChildren(node)[0] ?? null;
 }
@@ -396,14 +498,17 @@ export function blankLinesForCodeGap(
 	if (topLevel && mode === "none") return 0;
 
 	if (hasSharedDefinitionSubject(prevNode, nextNode)) {
-		return blankLinesBetweenSameNameDefinitions(options);
+		return blankLinesFromRange(
+			observedBlankLines,
+			blankLineRangeBetweenSameNameDefinitions(options),
+		);
 	}
 
 	if (isDeclarationNode(prevNode) && isDeclarationNode(nextNode)) {
-		return (
-			blankLinesBetweenDeclarationNodes(prevNode, nextNode, options) ??
-			blankLinesBetweenDefinitions(options)
-		);
+		const range =
+			blankLineRangeBetweenDeclarationNodes(prevNode, nextNode, options) ??
+			blankLineRangeBetweenDefinitions(options);
+		return blankLinesFromRange(observedBlankLines, range);
 	}
 
 	const maxBlankLines = maxBlankLinesBetweenCode(options);