kopytko-formatter 1.0.9 → 1.1.0

package/dist/src/formatter.js

@@ -2,22 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatText = formatText;
 exports.checkFormatting = checkFormatting;
-const builtins_1 = require("./builtins");
-const casing_1 = require("./casing");
-/** Canonical (catalog-cased) lookup tables, built once at module load. */
-const _builtinMap = new Map(builtins_1.BRIGHTSCRIPT_BUILTINS.map((b) => [b.name.toLowerCase(), b.name]));
-const _keywordSet = new Set(builtins_1.BRIGHTSCRIPT_KEYWORDS.map((k) => k.toLowerCase()));
-/** Mapping from compact end-keyword to spaced form. */
-const COMPACT_TO_SPACED = {
-    'endif': 'end if',
-    'endfunction': 'end function',
-    'endsub': 'end sub',
-    'endwhile': 'end while',
-    'endfor': 'end for',
-    'endtry': 'end try',
-};
+const kopytko_brightscript_parser_1 = require("kopytko-brightscript-parser");
+const kopytko_brightscript_parser_2 = require("kopytko-brightscript-parser");
+const index_1 = require("./cst-passes/index");
 /** Reverse mapping: spaced form → compact. */
-const SPACED_TO_COMPACT = Object.fromEntries(Object.entries(COMPACT_TO_SPACED).map(([k, v]) => [v, k]));
 /**
  * Formats BrightScript source code using an 11-pass engine.
  *
@@ -30,7 +18,7 @@ const SPACED_TO_COMPACT = Object.fromEntries(Object.entries(COMPACT_TO_SPACED).m
  * @param userFunctions - Known user-defined functions for casing normalization (optional).
  * @returns The formatted source text.
  */
-function formatText(source, config, casing = casing_1.DEFAULT_CASING_CONFIG, userFunctions = []) {
+function formatText(source, config, casing = kopytko_brightscript_parser_1.DEFAULT_CASING_CONFIG, userFunctions = []) {
     let lines = source.split(/\r?\n/);
     const detectedEnding = detectLineEnding(source);
     const lineEndStr = resolveLineEnding(config.lineEnding, detectedEnding);
@@ -39,62 +27,82 @@ function formatText(source, config, casing = casing_1.DEFAULT_CASING_CONFIG, use
         if (!userFuncMap.has(fn.nameLower))
             userFuncMap.set(fn.nameLower, fn.name);
     }
-    // Pass 1 — Import sorting
+    // Pass 1 — Import sorting (regex — complex multi-group sorting with trivia)
     lines = passImportSorting(lines, config);
-    // Pass 2 — Comment normalization
-    lines = passCommentNormalization(lines, config);
-    // Pass 3 — End keyword style + function vs sub
-    lines = passEndKeywordStyle(lines, config);
-    lines = passFunctionVsSub(lines, config);
-    // Pass 4 — Then style + parenthesis if case + catch paren strip
-    lines = passThenStyle(lines, config);
+    // Pass 2 — Comment normalization (CST)
+    lines = runCstOnLines(lines, lineEndStr, (0, index_1.commentNormalizationPass)({ commentStyle: config.commentStyle, spaceAfterCommentMarker: config.spaceAfterCommentMarker }));
+    // Pass 3 — End keyword style (CST) + function vs sub (CST)
+    if (config.endKeywordStyle !== 'preserve') {
+        lines = runCstOnLines(lines, lineEndStr, (0, index_1.endKeywordStylePass)(config.endKeywordStyle));
+    }
+    if (config.functionVsSubForVoid !== 'preserve' && config.functionVsSubForVoid !== 'allow-void') {
+        lines = runCstOnLines(lines, lineEndStr, (0, index_1.functionVsSubPass)(config.functionVsSubForVoid));
+    }
+    // Pass 4 — Then style (CST) + parenthesis if case (regex) + catch paren strip (regex)
+    if (config.thenStyle !== 'preserve') {
+        lines = runCstOnLines(lines, lineEndStr, (0, index_1.thenStylePass)(config.thenStyle));
+    }
     lines = passParenthesisIfCase(lines, config);
     lines = passStripCatchParens(lines);
-    // Pass 4c — Else on new line
+    // Pass 4c — Else on new line (regex)
     lines = passElseOnNewLine(lines, config);
-    // Pass 5 — Print statement handling
-    lines = passPrintStatement(lines, config);
-    // Pass 5b — Line comment position
+    // Pass 5 — Print statement handling (CST)
+    if (config.printStatement === 'remove') {
+        lines = runCstOnLines(lines, lineEndStr, (0, index_1.printStatementRemovalPass)());
+    }
+    // Pass 5b — Line comment position (regex)
     lines = passLineCommentPosition(lines, config);
-    // Pass 6 — Spacing rules
+    // Pass 6 — Spacing rules (regex)
     lines = passSpacing(lines, config);
-    // Pass 6b — Wrap long strings
+    // Pass 6b — Wrap long strings (regex)
     lines = passWrapLongStrings(lines, config);
-    // Pass 6c — String concatenation style
+    // Pass 6c — String concatenation style (regex)
     lines = passStringConcatStyle(lines, config);
-    // Pass 7 — Casing
-    lines = passCasing(lines, casing, userFuncMap);
-    // Pass 7b — Split array open bracket
+    // Pass 7 — Casing (CST)
+    lines = runCstOnLines(lines, lineEndStr, (0, index_1.casingPass)(casing, userFuncMap));
+    // Pass 7b — Split array open bracket (regex)
     lines = passSplitArrayOpenBracket(lines, config);
-    // Pass 7c — Associative array single-line threshold
+    // Pass 7c — Associative array single-line threshold (regex)
     lines = passAAThreshold(lines, config);
-    // Pass 8 — Indentation
+    // Pass 8 — Indentation (regex)
     lines = passIndentation(lines, config);
-    // Pass 8b — Trailing commas
+    // Pass 8b — Trailing commas (regex)
     lines = passTrailingCommas(lines, config);
-    // Pass 8c — Align assignments
+    // Pass 8c — Align assignments (regex)
     lines = passAlignAssignments(lines, config);
-    // Pass 8d — Multi-line param alignment
+    // Pass 8d — Multi-line param alignment (regex)
     lines = passParamAlignment(lines, config);
-    // Pass 9 — Blank line rules
+    // Pass 9 — Blank line rules (regex)
     lines = passBlankLines(lines, config);
-    // Pass 9b — Empty lines between methods
+    // Pass 9b — Empty lines between methods (regex)
     lines = passEmptyLinesBetweenMethods(lines, config);
-    // Pass 10 — Trailing whitespace
-    lines = passTrimTrailing(lines, config);
-    // Pass 11 — Comment width
+    // Pass 10 — Trailing whitespace (CST)
+    if (config.trimTrailingWhitespace) {
+        lines = runCstOnLines(lines, lineEndStr, (0, index_1.trailingWhitespacePass)());
+    }
+    // Pass 11 — Comment width (regex)
     lines = passCommentWidth(lines, config);
-    // Pass 12 — observeField style
+    // Pass 12 — observeField style (regex)
     lines = passObserveFieldStyle(lines, config);
-    // Pass 13 — m prefix style
+    // Pass 13 — m prefix style (regex)
     lines = passMPrefixStyle(lines, config);
-    // Pass 14 — Field access consistency
+    // Pass 14 — Field access consistency (regex)
     lines = passFieldAccessConsistency(lines, config);
     // Assemble result
     let newText = lines.join(lineEndStr);
     if (config.insertFinalNewline && newText.length > 0 && !newText.endsWith(lineEndStr)) {
         newText += lineEndStr;
     }
+    // ── Syntax safety verification ──────────────────────────────────────────
+    // Parse the formatted output to detect if formatting broke the syntax.
+    // If errors are found, return the original source unchanged.
+    if (config.verifySyntax !== false) {
+        const result = (0, kopytko_brightscript_parser_2.parse)(newText);
+        if (result.diagnostics.length > 0) {
+            // Formatting introduced syntax errors — fall back to original source
+            return source;
+        }
+    }
     return newText;
 }
 /**
@@ -106,6 +114,25 @@ function checkFormatting(source, config, casing, userFunctions) {
     return formatText(source, config, casing, userFunctions) === source;
 }
 // ---------------------------------------------------------------------------
+// CST ↔ lines bridge
+// ---------------------------------------------------------------------------
+/**
+ * Runs a CST pass on a string[] lines array.
+ * Joins lines → runs CST pass → splits back to lines.
+ * Falls back to original lines if the source has parse errors.
+ */
+function runCstOnLines(lines, lineEnd, pass) {
+    const source = lines.join(lineEnd);
+    const parseResult = (0, kopytko_brightscript_parser_2.parse)(source);
+    if (parseResult.diagnostics.length > 0)
+        return lines; // can't CST-transform broken code
+    const edits = pass(parseResult.root, source);
+    if (edits.length === 0)
+        return lines;
+    const result = (0, index_1.applyEdits)(source, edits);
+    return result.split(/\r?\n/);
+}
+// ---------------------------------------------------------------------------
 // Line ending helpers
 // ---------------------------------------------------------------------------
 function detectLineEnding(text) {
@@ -212,203 +239,9 @@ function passImportSorting(lines, config) {
     return [...sorted, ...lines.slice(blockEnd)];
 }
 // ---------------------------------------------------------------------------
-// Pass 2 — Comment normalization
 // ---------------------------------------------------------------------------
-function passCommentNormalization(lines, config) {
-    if (config.commentStyle === 'preserve' && !config.spaceAfterCommentMarker)
-        return lines;
-    return lines.map(line => {
-        const trimmed = line.trim();
-        if (/^\s*'\s*@(?:import|mock)\s+/.test(line))
-            return line;
-        const isTickComment = trimmed.startsWith("'");
-        const isRemComment = /^rem\b/i.test(trimmed);
-        if (!isTickComment && !isRemComment)
-            return line;
-        const indent = line.match(/^(\s*)/)?.[1] ?? '';
-        let content = isTickComment ? trimmed.slice(1) : trimmed.slice(3);
-        let marker;
-        if (config.commentStyle === 'preserve') {
-            marker = isTickComment ? "'" : trimmed.slice(0, 3);
-        }
-        else {
-            marker = config.commentStyle === "'" ? "'" : 'rem';
-        }
-        if (config.spaceAfterCommentMarker && content.length > 0 && !content.startsWith(' ')) {
-            content = ' ' + content;
-        }
-        return indent + marker + content;
-    });
-}
-// ---------------------------------------------------------------------------
-// Pass 3 — End keyword style
-// ---------------------------------------------------------------------------
-function passEndKeywordStyle(lines, config) {
-    if (config.endKeywordStyle === 'preserve')
-        return lines;
-    return lines.map(line => {
-        const lower = line.trim().toLowerCase();
-        const indent = line.match(/^(\s*)/)?.[1] ?? '';
-        if (config.endKeywordStyle === 'compact') {
-            const compact = SPACED_TO_COMPACT[lower];
-            if (compact)
-                return indent + compact;
-        }
-        else {
-            const spaced = COMPACT_TO_SPACED[lower];
-            if (spaced)
-                return indent + spaced;
-        }
-        return line;
-    });
-}
-// ---------------------------------------------------------------------------
-// Pass 3b — function vs sub for void
-// ---------------------------------------------------------------------------
-function passFunctionVsSub(lines, config) {
-    if (config.functionVsSubForVoid === 'preserve')
-        return lines;
-    const result = [...lines];
-    const namedDeclRegex = /^(\s*)(function|sub)\s+(\w+)\s*\((.*)\)(?:\s+as\s+(\w+))?\s*$/i;
-    const anonDeclRegex = /^(.*\b)(function|sub)(\s*\(.*\))(?:\s+as\s+(\w+))?\s*$/i;
-    for (let i = 0; i < result.length; i++) {
-        // Named declarations
-        const nm = namedDeclRegex.exec(result[i]);
-        if (nm) {
-            const [, indent, keyword, name, params, returnType] = nm;
-            const kw = keyword.toLowerCase();
-            const endIdx = findMatchingEnd(result, i);
-            if (endIdx < 0)
-                continue;
-            const hasExplicitReturnType = returnType && returnType.toLowerCase() !== 'void';
-            const hasValueReturn = hasReturnWithValue(result, i + 1, endIdx);
-            const isVoid = !hasExplicitReturnType && !hasValueReturn;
-            if (config.functionVsSubForVoid === 'sub' && kw === 'function' && isVoid) {
-                result[i] = `${indent}sub ${name}(${params})`;
-                const ei = result[endIdx].match(/^(\s*)/)?.[1] ?? '';
-                const el = result[endIdx].trim().toLowerCase();
-                if (el === 'end function')
-                    result[endIdx] = ei + 'end sub';
-                else if (el === 'endfunction')
-                    result[endIdx] = ei + 'endsub';
-            }
-            else if (config.functionVsSubForVoid === 'function' && kw === 'sub') {
-                result[i] = `${indent}function ${name}(${params}) as Void`;
-                const ei = result[endIdx].match(/^(\s*)/)?.[1] ?? '';
-                const el = result[endIdx].trim().toLowerCase();
-                if (el === 'end sub')
-                    result[endIdx] = ei + 'end function';
-                else if (el === 'endsub')
-                    result[endIdx] = ei + 'endfunction';
-            }
-            continue;
-        }
-        // Anonymous function declarations
-        const am = anonDeclRegex.exec(result[i]);
-        if (!am)
-            continue;
-        if (/^\s*(?:function|sub)\b/i.test(result[i]))
-            continue;
-        const [, prefix, keyword, paramsWithParens, returnType] = am;
-        const kw = keyword.toLowerCase();
-        const endIdx = findMatchingEnd(result, i);
-        if (endIdx < 0)
-            continue;
-        const hasExplicitReturnType = returnType && returnType.toLowerCase() !== 'void';
-        const hasValueReturn = hasReturnWithValue(result, i + 1, endIdx);
-        const isVoid = !hasExplicitReturnType && !hasValueReturn;
-        if (config.functionVsSubForVoid === 'sub' && kw === 'function' && isVoid) {
-            result[i] = `${prefix}sub${paramsWithParens}`;
-            replaceEndKeyword(result, endIdx, 'function', 'sub');
-        }
-        else if (config.functionVsSubForVoid === 'function' && kw === 'sub') {
-            result[i] = `${prefix}function${paramsWithParens} as Void`;
-            replaceEndKeyword(result, endIdx, 'sub', 'function');
-        }
-    }
-    return result;
-}
-function replaceEndKeyword(lines, idx, from, to) {
-    const spaced = new RegExp(`\\bend\\s+${from}\\b`, 'i');
-    const joined = new RegExp(`\\bend${from}\\b`, 'i');
-    if (spaced.test(lines[idx])) {
-        lines[idx] = lines[idx].replace(spaced, `end ${to}`);
-    }
-    else {
-        lines[idx] = lines[idx].replace(joined, `end${to}`);
-    }
-}
-function hasReturnWithValue(lines, startIdx, endIdx) {
-    let depth = 0;
-    for (let i = startIdx; i < endIdx; i++) {
-        const trimmed = lines[i].trim().toLowerCase();
-        if (/^(?:function|sub)\b/.test(trimmed) || isAnonFunctionOpener(trimmed))
-            depth++;
-        else if (/^(?:end\s*function|end\s*sub|endfunction|endsub)\b/.test(trimmed))
-            depth--;
-        if (depth > 0)
-            continue;
-        if (/^return(?:\s+\S|\{|\[|\()/i.test(trimmed))
-            return true;
-    }
-    return false;
-}
-function findMatchingEnd(lines, startIdx) {
-    let depth = 1;
-    for (let i = startIdx + 1; i < lines.length; i++) {
-        const lower = lines[i].trim().toLowerCase();
-        if (/^(?:function|sub)\b/i.test(lower) || isAnonFunctionOpener(lower))
-            depth++;
-        else if (/^(?:end\s*function|end\s*sub|endfunction|endsub)\b/i.test(lower)) {
-            if (--depth === 0)
-                return i;
-        }
-    }
-    return -1;
-}
 // ---------------------------------------------------------------------------
-// Pass 4 — Then style
 // ---------------------------------------------------------------------------
-function passThenStyle(lines, config) {
-    if (config.thenStyle === 'preserve')
-        return lines;
-    return lines.map(line => {
-        const trimmed = line.trim();
-        if (!/^(?:if|else\s*if|elseif)\b/i.test(trimmed))
-            return line;
-        const indent = line.match(/^(\s*)/)?.[1] ?? '';
-        const hasThen = /\bthen\b/i.test(trimmed);
-        let isSingleLine = false;
-        if (hasThen) {
-            const afterThen = trimmed.replace(/^.*?\bthen\b/i, '').trim();
-            isSingleLine = afterThen !== '' && !afterThen.startsWith("'") && !/^rem\b/i.test(afterThen);
-        }
-        const removeThen = () => {
-            const split = splitTrailingComment(trimmed);
-            const codeOnly = split.code.replace(/\s*\bthen\b\s*$/i, '').trimEnd();
-            return indent + codeOnly + (split.comment ? ' ' + split.comment : '');
-        };
-        switch (config.thenStyle) {
-            case 'always':
-                if (!hasThen)
-                    return indent + trimmed + ' then';
-                break;
-            case 'never':
-                if (hasThen && !isSingleLine)
-                    return removeThen();
-                break;
-            case 'multiline-only':
-                if (!hasThen)
-                    return indent + trimmed + ' then';
-                break;
-            case 'singleline-only':
-                if (hasThen && !isSingleLine)
-                    return removeThen();
-                break;
-        }
-        return line;
-    });
-}
 // ---------------------------------------------------------------------------
 // Pass 4b — Strip catch parentheses (always — BrightScript does not allow them)
 // ---------------------------------------------------------------------------
@@ -546,13 +379,6 @@ function passElseOnNewLine(lines, config) {
     return result;
 }
 // ---------------------------------------------------------------------------
-// Pass 5 — Print statement handling
-// ---------------------------------------------------------------------------
-function passPrintStatement(lines, config) {
-    if (config.printStatement !== 'remove')
-        return lines;
-    return lines.filter(line => !/^\s*(?:print|\?)\b/i.test(line));
-}
 // ---------------------------------------------------------------------------
 // Pass 5b — Line comment position
 // ---------------------------------------------------------------------------
@@ -796,17 +622,6 @@ function applyBracketAndCommaSpacing(line, config) {
     return result;
 }
 // ---------------------------------------------------------------------------
-// Pass 7 — Casing
-// ---------------------------------------------------------------------------
-function passCasing(lines, casing, userFuncMap) {
-    return lines.map(line => {
-        const trimmed = line.trim();
-        if (trimmed === '' || trimmed.startsWith("'") || /^rem\b/i.test(trimmed))
-            return line;
-        const indent = line.match(/^(\s*)/)?.[1] ?? '';
-        return indent + applyCasingToLine(trimmed, casing, userFuncMap);
-    });
-}
 // ---------------------------------------------------------------------------
 // Pass 7b — Split array open bracket
 // ---------------------------------------------------------------------------
@@ -1290,14 +1105,6 @@ function passEmptyLinesBetweenMethods(lines, config) {
     return out;
 }
 // ---------------------------------------------------------------------------
-// Pass 10 — Trim trailing whitespace
-// ---------------------------------------------------------------------------
-function passTrimTrailing(lines, config) {
-    if (!config.trimTrailingWhitespace)
-        return lines;
-    return lines.map(line => line.trimEnd());
-}
-// ---------------------------------------------------------------------------
 // Pass 11 — Comment width
 // ---------------------------------------------------------------------------
 function passCommentWidth(lines, config) {
@@ -1998,22 +1805,6 @@ function isReturnAloneInBlock(lines, returnIdx) {
     }
     return true;
 }
-// ---------------------------------------------------------------------------
-// Casing helpers
-// ---------------------------------------------------------------------------
-function applyCasingToLine(line, casing, userFuncMap) {
-    const segments = splitCodeSegments(line);
-    let result = '';
-    for (const seg of segments) {
-        if (seg.isCode) {
-            result += transformCodeSegment(seg.text, casing, userFuncMap);
-        }
-        else {
-            result += seg.text;
-        }
-    }
-    return result;
-}
 function splitCodeSegments(line) {
     const segments = [];
     let current = '';
@@ -2053,54 +1844,4 @@ function splitCodeSegments(line) {
     }
     return segments;
 }
-function transformCodeSegment(code, casing, userFuncMap) {
-    const exactMap = casing.exact ?? {};
-    const userFuncCasing = casing.userFunction ?? 'preserve';
-    return code.replace(/\b([a-zA-Z_]\w*)\b/g, (match, _group, offset) => {
-        const afterIdx = offset + match.length;
-        const restAfter = code.slice(afterIdx);
-        if (/^\s*:/.test(restAfter))
-            return match;
-        if (offset > 0 && code[offset - 1] === '.')
-            return match;
-        const lower = match.toLowerCase();
-        const exact = Object.prototype.hasOwnProperty.call(exactMap, lower) ? exactMap[lower] : undefined;
-        if (exact !== undefined)
-            return exact;
-        if (_keywordSet.has(lower)) {
-            let category = (0, builtins_1.getKeywordCategory)(lower);
-            if (lower === 'function' && offset >= 3) {
-                const before = code.slice(Math.max(0, offset - 10), offset);
-                if (/\bas\s+$/i.test(before)) {
-                    category = 'type';
-                }
-            }
-            const effectiveCasing = (0, casing_1.resolveKeywordCasing)(category, casing);
-            if (effectiveCasing !== 'preserve') {
-                return (0, casing_1.applyCasingWithOverrides)(match, effectiveCasing, exactMap);
-            }
-            return match;
-        }
-        if (_builtinMap.has(lower)) {
-            // Only treat as a built-in function when it is actually being called.
-            // Identifiers that happen to share a name with a built-in (e.g. a
-            // parameter named `str`) should not be re-cased.
-            if (!/^\s*\(/.test(restAfter))
-                return match;
-            const canonical = _builtinMap.get(lower);
-            if (casing.builtin !== 'preserve') {
-                return (0, casing_1.applyCasingWithOverrides)(canonical, casing.builtin, exactMap);
-            }
-            return canonical;
-        }
-        if (userFuncMap.has(lower)) {
-            const definitionName = userFuncMap.get(lower);
-            if (userFuncCasing !== 'preserve') {
-                return (0, casing_1.applyCasing)(definitionName, userFuncCasing);
-            }
-            return definitionName;
-        }
-        return match;
-    });
-}
 //# sourceMappingURL=formatter.js.map