@atlisp/lint 0.2.16 → 0.2.17

package/dist/fixes/index.js

@@ -2,184 +2,888 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FIXABLE_RULES = void 0;
 exports.applyFixesFromProviders = applyFixesFromProviders;
-const utils_1 = require("../utils");
 const nth_usage_1 = require("../checks/nth-usage");
+const parser_1 = require("@atlisp/parser");
+function buildPosToOffset(_content) {
+    return pos => pos.offset;
+}
+function findCloseParen(s, start) {
+    if (s[start] !== '(')
+        return -1;
+    let depth = 0;
+    let inStr = false;
+    for (let i = start; i < s.length; i++) {
+        if (inStr) {
+            if (s[i] === '\\') {
+                i++;
+                continue;
+            }
+            if (s[i] === '"')
+                inStr = false;
+            continue;
+        }
+        if (s[i] === ';') {
+            while (i < s.length && s[i] !== '\n')
+                i++;
+            continue;
+        }
+        if (s[i] === '"') {
+            inStr = true;
+            continue;
+        }
+        if (s[i] === '(')
+            depth++;
+        else if (s[i] === ')') {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}
+function buildLineOffsets(lines) {
+    const offsets = [];
+    let off = 0;
+    for (let i = 0; i < lines.length; i++) {
+        offsets.push(off);
+        off += lines[i].length + 1;
+    }
+    return offsets;
+}
+function extractNextForm(s, start) {
+    let i = start;
+    while (i < s.length && s[i] === ' ')
+        i++;
+    if (i >= s.length)
+        return ['', i];
+    if (s[i] === '(') {
+        const close = findCloseParen(s, i);
+        if (close > i)
+            return [s.slice(i, close + 1), close + 1];
+        return ['', i];
+    }
+    const atomMatch = s.slice(i).match(/^\S+/);
+    if (atomMatch)
+        return [atomMatch[0], i + atomMatch[0].length];
+    return ['', i];
+}
+function stripPrognWrapper(issues, content) {
+    const lines = content.split('\n');
+    const lineOffsets = buildLineOffsets(lines);
+    const ops = [];
+    for (const issue of issues) {
+        const lineIdx = issue.line - 1;
+        if (lineIdx < 0 || lineIdx >= lines.length)
+            continue;
+        const line = lines[lineIdx];
+        const pMatch = line.match(/\(progn(?=\s|$)/);
+        if (!pMatch)
+            continue;
+        const absP = lineOffsets[lineIdx] + pMatch.index;
+        const close = findCloseParen(content, absP);
+        if (close <= absP)
+            continue;
+        let argStart = absP + 6;
+        if (content[argStart] === ' ')
+            argStart++;
+        ops.push({ start: absP, end: close + 1, text: content.slice(argStart, close) });
+    }
+    ops.sort((a, b) => b.start - a.start);
+    for (const op of ops) {
+        content = content.slice(0, op.start) + op.text + content.slice(op.end);
+    }
+    return content;
+}
+function quote_style_fallback(issues, content) {
+    const lines = content.split('\n');
+    const lineOffsets = buildLineOffsets(lines);
+    const ops = [];
+    for (const issue of issues) {
+        const lineIdx = issue.line - 1;
+        if (lineIdx < 0 || lineIdx >= lines.length)
+            continue;
+        const line = lines[lineIdx];
+        const qMatch = line.match(/\(quote(?=\s|$)/);
+        if (!qMatch)
+            continue;
+        const absQ = lineOffsets[lineIdx] + qMatch.index;
+        const close = findCloseParen(content, absQ);
+        if (close <= absQ)
+            continue;
+        let argStart = absQ + 6;
+        if (content[argStart] === ' ')
+            argStart++;
+        ops.push({ start: absQ, end: close + 1, text: "'" + content.slice(argStart, close) });
+    }
+    ops.sort((a, b) => b.start - a.start);
+    for (const op of ops) {
+        content = content.slice(0, op.start) + op.text + content.slice(op.end);
+    }
+    return content;
+}
+function misplaced_else_fallback(issues, content) {
+    const lines = content.split('\n');
+    const lineOffsets = buildLineOffsets(lines);
+    const ops = [];
+    for (const issue of issues) {
+        const lineIdx = issue.line - 1;
+        if (lineIdx < 0 || lineIdx >= lines.length)
+            continue;
+        const line = lines[lineIdx];
+        const ifMatch = line.match(/\(if\s+\(not(?=\s|$)/);
+        if (!ifMatch)
+            continue;
+        const ifStart = ifMatch.index;
+        const absIf = lineOffsets[lineIdx] + ifStart;
+        const notStart = ifStart + ifMatch[0].length - 4;
+        const absNot = lineOffsets[lineIdx] + notStart;
+        const notClose = findCloseParen(content, absNot);
+        if (notClose <= absNot)
+            continue;
+        const ifClose = findCloseParen(content, absIf);
+        if (ifClose <= absIf)
+            continue;
+        const indent = line.slice(0, ifStart);
+        const condVar = content.slice(absNot + 5, notClose).trim();
+        const branchRaw = content.slice(notClose + 1, ifClose).trim();
+        const [thenForm, thenEnd] = extractNextForm(branchRaw, 0);
+        const elseForm = branchRaw.slice(thenEnd).trim();
+        if (!thenForm || !elseForm)
+            continue;
+        ops.push({
+            start: absIf,
+            end: ifClose + 1,
+            text: indent + '(if ' + condVar + ' ' + elseForm + ' ' + thenForm + ')',
+        });
+    }
+    ops.sort((a, b) => b.start - a.start);
+    for (const op of ops) {
+        content = content.slice(0, op.start) + op.text + content.slice(op.end);
+    }
+    return content;
+}
+function setq_multiple_fallback(issues, content) {
+    const lines = content.split('\n');
+    const lineOffsets = buildLineOffsets(lines);
+    const ops = [];
+    for (const issue of issues) {
+        const lineIdx = issue.line - 1;
+        if (lineIdx < 0 || lineIdx >= lines.length)
+            continue;
+        const line = lines[lineIdx];
+        const setqMatch = line.match(/\(setq(?=\s|$)/);
+        if (!setqMatch)
+            continue;
+        const absSetq = lineOffsets[lineIdx] + setqMatch.index;
+        const close = findCloseParen(content, absSetq);
+        if (close <= absSetq)
+            continue;
+        let scan = close + 1;
+        while (scan < content.length && (content[scan] === ' ' || content[scan] === '\t' || content[scan] === '\n'))
+            scan++;
+        if (scan >= content.length || content[scan] !== '(')
+            continue;
+        const nextClose = findCloseParen(content, scan);
+        if (nextClose <= scan)
+            continue;
+        const nextForm = content.slice(scan, nextClose + 1);
+        const nextMatch = nextForm.match(/^\(setq\s+(.*)\)\s*$/);
+        if (!nextMatch)
+            continue;
+        ops.push({ start: close, end: nextClose + 1, text: ' ' + nextMatch[1] + ')' });
+    }
+    ops.sort((a, b) => b.start - a.start);
+    for (const op of ops) {
+        content = content.slice(0, op.start) + op.text + content.slice(op.end);
+    }
+    return content;
+}
+function append_single_fallback(issues, content) {
+    const lines = content.split('\n');
+    const lineOffsets = buildLineOffsets(lines);
+    const ops = [];
+    for (const issue of issues) {
+        const lineIdx = issue.line - 1;
+        if (lineIdx < 0 || lineIdx >= lines.length)
+            continue;
+        const line = lines[lineIdx];
+        const aMatch = line.match(/\(append(?=\s|$)/);
+        if (!aMatch)
+            continue;
+        const absA = lineOffsets[lineIdx] + aMatch.index;
+        const close = findCloseParen(content, absA);
+        if (close <= absA)
+            continue;
+        const inner = content.slice(absA + 8, close).trim();
+        const listMatch = inner.match(/^\(list\s+(.*)\)\s*$/);
+        if (!listMatch)
+            continue;
+        ops.push({ start: absA, end: close + 1, text: '(cons ' + listMatch[1] + ')' });
+    }
+    ops.sort((a, b) => b.start - a.start);
+    for (const op of ops) {
+        content = content.slice(0, op.start) + op.text + content.slice(op.end);
+    }
+    return content;
+}
+function cond_simplify_fallback(issues, content) {
+    const lines = content.split('\n');
+    const lineOffsets = buildLineOffsets(lines);
+    const ops = [];
+    for (const issue of issues) {
+        const lineIdx = issue.line - 1;
+        if (lineIdx < 0 || lineIdx >= lines.length)
+            continue;
+        const line = lines[lineIdx];
+        const condMatch = line.match(/\(cond(?=\s|$)/);
+        if (!condMatch)
+            continue;
+        const condIdx = condMatch.index;
+        const absCond = lineOffsets[lineIdx] + condIdx;
+        const condEnd = findCloseParen(content, absCond);
+        if (condEnd <= absCond)
+            continue;
+        const branchOpen = content.indexOf('(', absCond + 6);
+        if (branchOpen === -1 || branchOpen >= condEnd)
+            continue;
+        const branchEnd = findCloseParen(content, branchOpen);
+        if (branchEnd <= branchOpen)
+            continue;
+        const branchContent = content.slice(branchOpen + 1, branchEnd).trim();
+        const [testExpr, testEnd] = extractNextForm(branchContent, 0);
+        const bodyExpr = branchContent.slice(testEnd).trim();
+        if (!testExpr || !bodyExpr)
+            continue;
+        const indent = line.slice(0, condIdx);
+        ops.push({ start: absCond, end: condEnd + 1, text: indent + '(if ' + testExpr + ' ' + bodyExpr + ')' });
+    }
+    ops.sort((a, b) => b.start - a.start);
+    for (const op of ops) {
+        content = content.slice(0, op.start) + op.text + content.slice(op.end);
+    }
+    return content;
+}
+function while_constant_fallback(issues, content) {
+    const lines = content.split('\n');
+    const lineOffsets = buildLineOffsets(lines);
+    const ops = [];
+    for (const issue of issues) {
+        const lineIdx = issue.line - 1;
+        if (lineIdx < 0 || lineIdx >= lines.length)
+            continue;
+        const line = lines[lineIdx];
+        const trimmed = line.trim();
+        const nilMatch = trimmed.match(/^\(\s*while\s+nil\s+(.*)\)\s*$/);
+        if (!nilMatch) {
+            const wMatch = line.match(/\(while(?=\s|$)/);
+            if (!wMatch)
+                continue;
+            const absW = lineOffsets[lineIdx] + wMatch.index;
+            const close = findCloseParen(content, absW);
+            if (close <= absW)
+                continue;
+            const afterKw = absW + 6;
+            const kwEnd = afterKw + (content[afterKw] === ' ' || content[afterKw] === '\t' ? 1 : 0);
+            const nilIdx = content.indexOf('nil', kwEnd);
+            if (nilIdx === -1 || nilIdx >= close)
+                continue;
+            ops.push({ start: absW, end: close + 1, text: 'nil' });
+            continue;
+        }
+        const absLineStart = lineOffsets[lineIdx];
+        const absLineEnd = absLineStart + line.length;
+        ops.push({ start: absLineStart, end: absLineEnd, text: 'nil' });
+    }
+    ops.sort((a, b) => b.start - a.start);
+    for (const op of ops) {
+        content = content.slice(0, op.start) + op.text + content.slice(op.end);
+    }
+    return content;
+}
+function redundant_cond_fallback(issues, content) {
+    const lines = content.split('\n');
+    const lineOffsets = buildLineOffsets(lines);
+    const ops = [];
+    for (const issue of issues) {
+        const lineIdx = issue.line - 1;
+        if (lineIdx < 0 || lineIdx >= lines.length)
+            continue;
+        const line = lines[lineIdx];
+        const m = line.match(/^(\s*)\(cond\s+\(\(([^)]+)\)\s+\(([^)]*)\)\s*\)\s*\)$/);
+        if (m) {
+            ops.push({
+                start: lineOffsets[lineIdx],
+                end: lineOffsets[lineIdx] + line.length,
+                text: m[1] + '(if (' + m[2] + ') (' + m[3] + '))',
+            });
+            continue;
+        }
+        const condMatch = line.match(/\(cond(?=\s|$)/);
+        if (!condMatch)
+            continue;
+        const condIdx = condMatch.index;
+        const absCond = lineOffsets[lineIdx] + condIdx;
+        const condEnd = findCloseParen(content, absCond);
+        if (condEnd <= absCond)
+            continue;
+        const branchOpen = content.indexOf('(', absCond + 6);
+        if (branchOpen === -1 || branchOpen >= condEnd)
+            continue;
+        const branchEnd = findCloseParen(content, branchOpen);
+        if (branchEnd <= branchOpen)
+            continue;
+        const indent = line.slice(0, condIdx);
+        const branchInner = content.slice(branchOpen + 1, branchEnd).trim();
+        const [testExpr, testEnd] = extractNextForm(branchInner, 0);
+        const bodyExpr = branchInner.slice(testEnd).trim();
+        if (!testExpr || !bodyExpr)
+            continue;
+        ops.push({ start: absCond, end: condEnd + 1, text: indent + '(if ' + testExpr + ' ' + bodyExpr + ')' });
+    }
+    ops.sort((a, b) => b.start - a.start);
+    for (const op of ops) {
+        content = content.slice(0, op.start) + op.text + content.slice(op.end);
+    }
+    return content;
+}
+function quote_vs_function_fallback(issues, content) {
+    const lines = content.split('\n');
+    const lineOffsets = buildLineOffsets(lines);
+    const ops = [];
+    for (const issue of issues) {
+        const lineIdx = issue.line - 1;
+        if (lineIdx < 0 || lineIdx >= lines.length)
+            continue;
+        const line = lines[lineIdx];
+        const qIdx = line.indexOf("'(lambda");
+        if (qIdx !== -1) {
+            const absQuotePos = lineOffsets[lineIdx] + qIdx;
+            const absLambdaOpen = absQuotePos + 1;
+            const closePos = findCloseParen(content, absLambdaOpen);
+            if (closePos !== -1) {
+                ops.push({ start: absQuotePos, end: absQuotePos + 1, text: '(function ' });
+                ops.push({ start: closePos + 1, end: closePos + 1, text: ')' });
+            }
+            continue;
+        }
+        const explicitQuote = line.match(/\(quote\s+\(lambda/);
+        if (explicitQuote) {
+            const absQuotePos = lineOffsets[lineIdx] + explicitQuote.index;
+            const beforeLambda = line.indexOf('(lambda', explicitQuote.index);
+            const quoteEnd = lineOffsets[lineIdx] + beforeLambda;
+            ops.push({ start: absQuotePos, end: quoteEnd, text: '(function ' });
+        }
+    }
+    ops.sort((a, b) => b.start - a.start);
+    for (const op of ops) {
+        content = content.slice(0, op.start) + op.text + content.slice(op.end);
+    }
+    return content;
+}
 const FIX_PROVIDERS = {
     redundant_quotes(line) {
         return line.replace(/''(\S)/g, "'$1");
     },
-    double_not(line) {
-        return line.replace(/\(not\s+\(not\s+/g, '(not ');
-    },
-    redundant_nil_else(line) {
-        return line.replace(/\s+nil\s*\)$/, ')');
-    },
-    single_arg_and_or(line) {
-        const m = line.match(/\((and|or)\s+([^)\s]+)\s*\)/);
-        return m ? m[2] : line;
-    },
-    redundant_progn(line) {
-        const proIdx = line.indexOf('(progn ');
-        if (proIdx === -1)
-            return line;
-        const beforePro = line.slice(0, proIdx);
-        const close = (0, utils_1.findMatchingParen)(line, proIdx);
-        if (close <= proIdx)
-            return line;
-        const inner = line.slice(proIdx + 7, close);
-        const rest = line.slice(close + 1);
-        return beforePro + inner + rest;
-    },
     redundant_let(line) {
         return line.replace(/\(let\s+\(\)\s*/, '(progn ');
     },
-    quote_style(line) {
-        const qIdx = line.indexOf('(quote ');
-        if (qIdx === -1)
-            return line;
-        const beforeQ = line.slice(0, qIdx);
-        const close = (0, utils_1.findMatchingParen)(line, qIdx);
-        if (close <= qIdx)
-            return line;
-        const quoted = line.slice(qIdx + 7, close);
-        const rest = line.slice(close + 1);
-        return beforeQ + "'" + quoted + rest;
-    },
-    redundant_if(line) {
-        const pIdx = line.indexOf('(progn ');
-        if (pIdx === -1)
-            return line;
-        const beforeP = line.slice(0, pIdx);
-        const close = (0, utils_1.findMatchingParen)(line, pIdx);
-        if (close <= pIdx)
-            return line;
-        const inner = line.slice(pIdx + 7, close);
-        const rest = line.slice(close + 1);
-        return beforeP + inner + rest;
-    },
-    misplaced_else(line) {
-        const ifStart = line.indexOf('(if (not ');
-        if (ifStart === -1)
-            return line;
-        const notIdx = line.indexOf('(not ', ifStart);
-        if (notIdx === -1)
-            return line;
-        const notClose = (0, utils_1.findMatchingParen)(line, notIdx);
-        if (notClose <= notIdx)
-            return line;
-        const ifClose = (0, utils_1.findMatchingParen)(line, ifStart);
-        if (ifClose <= ifStart)
-            return line;
-        const indent = line.slice(0, ifStart);
-        const condVar = line.slice(notIdx + 5, notClose);
-        const branchContent = line.slice(notClose + 1, ifClose).trim();
-        const [thenForm, thenEnd] = (0, utils_1.extractForm)(branchContent, 0);
-        const elseForm = branchContent.slice(thenEnd).trim();
-        if (!thenForm || !elseForm)
-            return line;
-        const rest = line.slice(ifClose + 1);
-        return indent + '(if ' + condVar + ' ' + elseForm + ' ' + thenForm + ')' + rest;
-    },
-    setq_multiple(line) {
-        const fixed = line.replace(/\)\(setq\s+/g, ' ');
-        if (fixed === line)
-            return line;
-        const merged = line.replace(/^\(\s*setq\s+/, '(setq ');
-        if (merged.includes('setq') && !merged.match(/\)\(/))
-            return merged;
-        return line.replace(/\)\(setq\s+/g, '\n');
-    },
-    append_single(line) {
-        const aIdx = line.indexOf('(append ');
-        if (aIdx === -1)
-            return line;
-        const close = (0, utils_1.findMatchingParen)(line, aIdx);
-        if (close <= aIdx)
-            return line;
-        const inner = line.slice(aIdx + 8, close);
-        const listMatch = inner.match(/^\(list\s+(.*)\)\s*$/);
-        if (!listMatch)
-            return line;
-        return line.slice(0, aIdx) + '(cons ' + listMatch[1] + ')' + line.slice(close + 1);
-    },
     nth_usage(line) {
         return (0, nth_usage_1.replaceNthUsage)(line) || line;
     },
     setq_single_arg(line) {
         return line;
     },
-    extra_parens(line) {
-        return line.replace(/\){2,}/g, ')');
-    },
-    empty_branch(line) {
-        return line.replace(/\(if\s+\S+\s*\)/g, m => m.slice(0, -1) + ' nil)');
-    },
     comment_style(line) {
         return line.replace(/^(\s*;)([^ ;|].*)$/gm, '$1 $2');
     },
     eq_usage(line) {
         return line.replace(/\(eq\s+(\S+)\s+(\d+)\s*\)/g, '(= $1 $2)');
     },
-    cond_simplify(line) {
-        const condIdx = line.indexOf('(cond ');
-        if (condIdx === -1)
-            return line;
-        const condEnd = (0, utils_1.findMatchingParen)(line, condIdx);
-        if (condEnd <= condIdx)
-            return line;
-        const inner = line.slice(condIdx + 6, condEnd).trim();
-        const branchOpen = inner.indexOf('(');
-        if (branchOpen === -1)
-            return line;
-        const branchEnd = (0, utils_1.findMatchingParen)(inner, branchOpen);
-        if (branchEnd <= branchOpen)
-            return line;
-        const indent = line.slice(0, condIdx);
-        const branchContent = inner.slice(branchOpen + 1, branchEnd).trim();
-        const space = branchContent.search(/\s+/);
-        if (space === -1)
-            return line;
-        const testExpr = branchContent.slice(0, space);
-        const bodyExpr = branchContent.slice(space).trim();
-        const rest = line.slice(condEnd + 1);
-        return indent + '(if ' + testExpr + ' ' + bodyExpr + ')' + rest;
-    },
     self_compare(line) {
         return line.replace(/\((?:[=/<>]+|eq|equal)\s+(\S+)\s+\1\s*\)/g, 'T');
     },
-    while_constant(line) {
-        const trimmed = line.trim();
-        const nilMatch = trimmed.match(/^\(\s*while\s+nil\s+(.*)\)\s*$/);
-        if (!nilMatch)
-            return line;
-        return line.replace(trimmed, 'nil');
-    },
     redundant_list(line) {
         return line.replace(/\(\s*list\s*\)/g, 'nil');
     },
     zerop_usage(line) {
         return line.replace(/\(=\s+(\S+)\s+0\s*\)/g, '(zerop $1)').replace(/\(=\s+0\s+(\S+)\s*\)/g, '(zerop $1)');
     },
-    redundant_cond(line) {
-        const m = line.match(/^(\s*)\(cond\s+\(\(([^)]+)\)\s+\(([^)]*)\)\s*\)\s*\)$/);
-        if (!m)
-            return line;
-        return `${m[1]}(if (${m[2]}) (${m[3]}))`;
+};
+const CONTENT_FIX_PROVIDERS = {
+    double_not(_issues, content) {
+        return content.replace(/\(not\s+\(not\s+/g, '(not ');
+    },
+    redundant_nil_else(issues, content) {
+        const ops = [];
+        const lines = content.split('\n');
+        const lineOffsets = buildLineOffsets(lines);
+        for (const issue of issues) {
+            const lineIdx = issue.line - 1;
+            if (lineIdx < 0 || lineIdx >= lines.length)
+                continue;
+            const abs = lineOffsets[lineIdx];
+            const m = lines[lineIdx].match(/(\s+)nil\s*\)\s*$/);
+            if (m) {
+                const idx = abs + m.index + m[1].length;
+                ops.push({ start: idx, end: idx + 3, text: '' });
+            }
+        }
+        ops.sort((a, b) => b.start - a.start);
+        for (const op of ops) {
+            content = content.slice(0, op.start) + op.text + content.slice(op.end);
+        }
+        return content;
+    },
+    single_arg_and_or(issues, content) {
+        const ops = [];
+        const lines = content.split('\n');
+        const lineOffsets = buildLineOffsets(lines);
+        for (const issue of issues) {
+            const lineIdx = issue.line - 1;
+            if (lineIdx < 0 || lineIdx >= lines.length)
+                continue;
+            const line = lines[lineIdx];
+            const m = line.match(/\((and|or)\s+([^)\s]+)\s*\)/);
+            if (m) {
+                const start = lineOffsets[lineIdx] + m.index;
+                const end = lineOffsets[lineIdx] + m.index + m[0].length;
+                ops.push({ start, end, text: m[2] });
+            }
+        }
+        ops.sort((a, b) => b.start - a.start);
+        for (const op of ops) {
+            content = content.slice(0, op.start) + op.text + content.slice(op.end);
+        }
+        return content;
+    },
+    redundant_progn(issues, content, ast, posToOffset) {
+        if (!ast || !posToOffset)
+            return stripPrognWrapper(issues, content);
+        const prognNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'progn'));
+        if (prognNodes.length === 0)
+            return content;
+        const issueLines = new Set(issues.map(i => i.line));
+        const ops = [];
+        for (const node of prognNodes) {
+            if (!node.end || !issueLines.has(node.pos.line))
+                continue;
+            const start = posToOffset(node.pos);
+            const end = posToOffset(node.end);
+            let argStart = start + 6;
+            if (content[argStart] === ' ')
+                argStart++;
+            const inner = content.slice(argStart, end - 1);
+            ops.push({ start, end, text: inner });
+        }
+        if (ops.length === 0)
+            return stripPrognWrapper(issues, content);
+        ops.sort((a, b) => b.start - a.start);
+        for (const op of ops) {
+            content = content.slice(0, op.start) + op.text + content.slice(op.end);
+        }
+        return content;
+    },
+    quote_style(issues, content, ast, posToOffset) {
+        if (!ast || !posToOffset)
+            return quote_style_fallback(issues, content);
+        const quoteNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'quote'));
+        if (quoteNodes.length === 0)
+            return content;
+        const issueLines = new Set(issues.map(i => i.line));
+        const ops = [];
+        for (const node of quoteNodes) {
+            if (!node.end || !issueLines.has(node.pos.line))
+                continue;
+            if (content[posToOffset(node.pos)] !== '(')
+                continue;
+            const start = posToOffset(node.pos);
+            const end = posToOffset(node.end);
+            let afterQuote = start + 6;
+            if (content[afterQuote] === ' ')
+                afterQuote++;
+            const quoted = content.slice(afterQuote, end - 1);
+            ops.push({ start, end, text: "'" + quoted });
+        }
+        if (ops.length === 0)
+            return quote_style_fallback(issues, content);
+        ops.sort((a, b) => b.start - a.start);
+        for (const op of ops) {
+            content = content.slice(0, op.start) + op.text + content.slice(op.end);
+        }
+        return content;
+    },
+    redundant_if(issues, content, ast, posToOffset) {
+        if (!ast || !posToOffset)
+            return stripPrognWrapper(issues, content);
+        const prognNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'progn') && n.parent !== undefined && (0, parser_1.astIsList)(n.parent, 'if'));
+        if (prognNodes.length === 0)
+            return content;
+        const issueLines = new Set(issues.map(i => i.line));
+        const ops = [];
+        for (const node of prognNodes) {
+            if (!node.end || !issueLines.has(node.pos.line))
+                continue;
+            const start = posToOffset(node.pos);
+            const end = posToOffset(node.end);
+            let argStart = start + 6;
+            if (content[argStart] === ' ')
+                argStart++;
+            const inner = content.slice(argStart, end - 1);
+            ops.push({ start, end, text: inner });
+        }
+        if (ops.length === 0)
+            return stripPrognWrapper(issues, content);
+        ops.sort((a, b) => b.start - a.start);
+        for (const op of ops) {
+            content = content.slice(0, op.start) + op.text + content.slice(op.end);
+        }
+        return content;
+    },
+    misplaced_else(issues, content, ast, posToOffset) {
+        if (!ast || !posToOffset)
+            return misplaced_else_fallback(issues, content);
+        const ifNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'if') && n.children && n.children.length >= 4 && (0, parser_1.astIsList)(n.children[1], 'not'));
+        if (ifNodes.length === 0)
+            return content;
+        const issueLines = new Set(issues.map(i => i.line));
+        const ops = [];
+        for (const node of ifNodes) {
+            if (!node.end || !issueLines.has(node.pos.line))
+                continue;
+            if (!(0, parser_1.astIsList)(node))
+                continue;
+            const start = posToOffset(node.pos);
+            const end = posToOffset(node.end);
+            const indent = ' '.repeat(node.pos.col - 1);
+            const notForm = node.children[1];
+            if (!(0, parser_1.astIsList)(notForm))
+                continue;
+            const condForm = notForm.children[1];
+            const condStart = posToOffset(condForm.pos);
+            const condEnd = posToOffset(condForm.end);
+            const condRaw = content.slice(condStart, condEnd);
+            const thenRaw = content.slice(posToOffset(node.children[2].pos), posToOffset(node.children[2].end));
+            const elseRaw = content.slice(posToOffset(node.children[3].pos), posToOffset(node.children[3].end));
+            ops.push({ start, end, text: indent + '(if ' + condRaw + ' ' + elseRaw + ' ' + thenRaw + ')' });
+        }
+        if (ops.length === 0)
+            return misplaced_else_fallback(issues, content);
+        ops.sort((a, b) => b.start - a.start);
+        for (const op of ops) {
+            content = content.slice(0, op.start) + op.text + content.slice(op.end);
+        }
+        return content;
+    },
+    setq_multiple(issues, content, ast, posToOffset) {
+        if (!ast || !posToOffset)
+            return setq_multiple_fallback(issues, content);
+        const setqNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'setq'));
+        if (setqNodes.length < 2)
+            return content;
+        const issueLines = new Set(issues.map(i => i.line));
+        const ops = [];
+        for (let i = 0; i < setqNodes.length - 1; i++) {
+            const a = setqNodes[i];
+            const b = setqNodes[i + 1];
+            if (!a.end || !b.end)
+                continue;
+            if (a.parent !== b.parent)
+                continue;
+            if (!issueLines.has(a.pos.line))
+                continue;
+            const parent = a.parent;
+            if (!parent || !(0, parser_1.astIsList)(parent))
+                continue;
+            const aIdx = parent.children.indexOf(a);
+            if (aIdx === -1 || parent.children[aIdx + 1] !== b)
+                continue;
+            const bStart = posToOffset(b.pos);
+            const bEnd = posToOffset(b.end);
+            let bodyStart = bStart + 5;
+            if (content[bodyStart] === ' ')
+                bodyStart++;
+            const body2 = content.slice(bodyStart, bEnd - 1);
+            const aEndPos = posToOffset(a.end) - 1;
+            ops.push({ start: aEndPos, end: bEnd, text: ' ' + body2 + ')' });
+        }
+        if (ops.length === 0)
+            return setq_multiple_fallback(issues, content);
+        ops.sort((a, b) => b.start - a.start);
+        for (const op of ops) {
+            content = content.slice(0, op.start) + op.text + content.slice(op.end);
+        }
+        return content;
+    },
+    append_single(issues, content, ast, posToOffset) {
+        if (!ast || !posToOffset)
+            return append_single_fallback(issues, content);
+        const appendNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'append'));
+        if (appendNodes.length === 0)
+            return content;
+        const issueLines = new Set(issues.map(i => i.line));
+        const ops = [];
+        for (const node of appendNodes) {
+            if (!node.end || !issueLines.has(node.pos.line))
+                continue;
+            if (!(0, parser_1.astIsList)(node) || node.children.length < 2)
+                continue;
+            const arg = node.children[1];
+            if (!(0, parser_1.astIsList)(arg, 'list'))
+                continue;
+            const start = posToOffset(node.pos);
+            const end = posToOffset(node.end);
+            const listStart = posToOffset(arg.children[1].pos);
+            const listEnd = posToOffset(arg.children[1].end);
+            const listBody = content.slice(listStart, listEnd);
+            ops.push({ start, end, text: '(cons ' + listBody + ')' });
+        }
+        if (ops.length === 0)
+            return append_single_fallback(issues, content);
+        ops.sort((a, b) => b.start - a.start);
+        for (const op of ops) {
+            content = content.slice(0, op.start) + op.text + content.slice(op.end);
+        }
+        return content;
+    },
+    extra_parens(issues, content) {
+        const lines = content.split('\n');
+        const ops = [];
+        for (const issue of issues) {
+            const lineIdx = issue.line - 1;
+            if (lineIdx < 0 || lineIdx >= lines.length)
+                continue;
+            const line = lines[lineIdx];
+            const dep = line.match(/\){2,}/);
+            if (!dep)
+                continue;
+            const abs = buildLineOffsets(lines)[lineIdx] + dep.index;
+            const count = dep[0].length;
+            let depth = 0;
+            for (let i = 0; i < content.length; i++) {
+                const c = content[i];
+                if (c === ';') {
+                    while (i < content.length && content[i] !== '\n')
+                        i++;
+                    continue;
+                }
+                if (c === '(')
+                    depth++;
+                else if (c === ')') {
+                    depth--;
+                    if (depth < 0 && i >= abs && i < abs + count) {
+                        ops.push({ start: i, end: i + 1, text: '' });
+                    }
+                }
+            }
+        }
+        ops.sort((a, b) => b.start - a.start);
+        for (const op of ops) {
+            content = content.slice(0, op.start) + op.text + content.slice(op.end);
+        }
+        return content;
+    },
+    empty_branch(issues, content) {
+        const ops = [];
+        const lines = content.split('\n');
+        const lineOffsets = buildLineOffsets(lines);
+        for (const issue of issues) {
+            const lineIdx = issue.line - 1;
+            if (lineIdx < 0 || lineIdx >= lines.length)
+                continue;
+            const line = lines[lineIdx];
+            const m = line.match(/\(if\s+(\S+)\s*\)/);
+            if (!m)
+                continue;
+            const start = lineOffsets[lineIdx] + m.index;
+            const end = start + m[0].length;
+            ops.push({ start: end - 1, end, text: ' nil)' });
+        }
+        ops.sort((a, b) => b.start - a.start);
+        for (const op of ops) {
+            content = content.slice(0, op.start) + op.text + content.slice(op.end);
+        }
+        return content;
+    },
+    cond_simplify(issues, content, ast, posToOffset) {
+        if (!ast || !posToOffset)
+            return cond_simplify_fallback(issues, content);
+        const condNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'cond') && n.children && n.children.length >= 2 && (0, parser_1.astIsList)(n.children[1]));
+        if (condNodes.length === 0)
+            return content;
+        const issueLines = new Set(issues.map(i => i.line));
+        const ops = [];
+        for (const node of condNodes) {
+            if (!node.end || !issueLines.has(node.pos.line))
+                continue;
+            if (!(0, parser_1.astIsList)(node) || node.children.length !== 2)
+                continue;
+            const branch = node.children[1];
+            if (!(0, parser_1.astIsList)(branch) || branch.children.length < 2)
+                continue;
+            const start = posToOffset(node.pos);
+            const end = posToOffset(node.end);
+            const indent = ' '.repeat(node.pos.col - 1);
+            const testStart = posToOffset(branch.children[0].pos);
+            const testEnd = posToOffset(branch.children[0].end);
+            const testExpr = content.slice(testStart, testEnd);
+            const bodyStart = posToOffset(branch.children[1].pos);
+            const bodyEnd = posToOffset(branch.children[1].end);
+            const bodyExpr = content.slice(bodyStart, bodyEnd);
+            ops.push({ start, end, text: indent + '(if ' + testExpr + ' ' + bodyExpr + ')' });
+        }
+        if (ops.length === 0)
+            return cond_simplify_fallback(issues, content);
+        ops.sort((a, b) => b.start - a.start);
+        for (const op of ops) {
+            content = content.slice(0, op.start) + op.text + content.slice(op.end);
+        }
+        return content;
+    },
+    while_constant(issues, content, ast, posToOffset) {
+        if (!ast || !posToOffset)
+            return while_constant_fallback(issues, content);
+        const whileNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'while'));
+        if (whileNodes.length === 0)
+            return content;
+        const issueLines = new Set(issues.map(i => i.line));
+        const ops = [];
+        for (const node of whileNodes) {
+            if (!node.end || !issueLines.has(node.pos.line))
+                continue;
+            if (!(0, parser_1.astIsList)(node) || node.children.length < 2)
+                continue;
+            const test = node.children[1];
+            if (test.type !== 'symbol' || test.name !== 'nil')
+                continue;
+            const start = posToOffset(node.pos);
+            const end = posToOffset(node.end);
+            ops.push({ start, end, text: 'nil' });
+        }
+        if (ops.length === 0)
+            return while_constant_fallback(issues, content);
+        ops.sort((a, b) => b.start - a.start);
+        for (const op of ops) {
+            content = content.slice(0, op.start) + op.text + content.slice(op.end);
+        }
+        return content;
+    },
+    redundant_cond(issues, content, ast, posToOffset) {
+        if (!ast || !posToOffset)
+            return redundant_cond_fallback(issues, content);
+        const condNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'cond') && n.children && n.children.length === 2 && (0, parser_1.astIsList)(n.children[1]));
+        if (condNodes.length === 0)
+            return content;
+        const issueLines = new Set(issues.map(i => i.line));
+        const ops = [];
+        for (const node of condNodes) {
+            if (!node.end || !issueLines.has(node.pos.line))
+                continue;
+            if (!(0, parser_1.astIsList)(node))
+                continue;
+            const branch = node.children[1];
+            if (!(0, parser_1.astIsList)(branch) || branch.children.length < 2)
+                continue;
+            const start = posToOffset(node.pos);
+            const end = posToOffset(node.end);
+            const indent = ' '.repeat(node.pos.col - 1);
+            const testStart = posToOffset(branch.children[0].pos);
+            const testEnd = posToOffset(branch.children[0].end);
+            const bodyStart = posToOffset(branch.children[1].pos);
+            const bodyEnd = posToOffset(branch.children[1].end);
+            ops.push({
+                start,
+                end,
+                text: indent + '(if ' + content.slice(testStart, testEnd) + ' ' + content.slice(bodyStart, bodyEnd) + ')',
+            });
+        }
+        if (ops.length === 0)
+            return redundant_cond_fallback(issues, content);
+        ops.sort((a, b) => b.start - a.start);
+        for (const op of ops) {
+            content = content.slice(0, op.start) + op.text + content.slice(op.end);
+        }
+        return content;
+    },
+    quote_vs_function(issues, content, ast, posToOffset) {
+        if (!ast || !posToOffset)
+            return quote_vs_function_fallback(issues, content);
+        const quoteNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'quote'));
+        if (quoteNodes.length === 0)
+            return content;
+        const issueLines = new Set(issues.map(i => i.line));
+        const ops = [];
+        for (const node of quoteNodes) {
+            if (!node.end || !issueLines.has(node.pos.line))
+                continue;
+            if (!(0, parser_1.astIsList)(node) || node.children.length < 2)
+                continue;
+            const quoted = node.children[1];
+            if (!(0, parser_1.astIsList)(quoted, 'lambda'))
+                continue;
+            const isShorthand = content[posToOffset(node.pos)] === "'";
+            if (isShorthand) {
+                ops.push({ start: posToOffset(node.pos), end: posToOffset(node.pos) + 1, text: '(function ' });
+                ops.push({ start: posToOffset(node.end), end: posToOffset(node.end), text: ')' });
+            }
+            else {
+                const lambdaStart = posToOffset(node.children[1].pos);
+                ops.push({ start: posToOffset(node.pos), end: lambdaStart, text: '(function ' });
+            }
+        }
+        if (ops.length === 0)
+            return quote_vs_function_fallback(issues, content);
+        ops.sort((a, b) => b.start - a.start);
+        for (const op of ops) {
+            content = content.slice(0, op.start) + op.text + content.slice(op.end);
+        }
+        return content;
     },
 };
-exports.FIXABLE_RULES = new Set(Object.keys(FIX_PROVIDERS));
+exports.FIXABLE_RULES = new Set([...Object.keys(FIX_PROVIDERS), ...Object.keys(CONTENT_FIX_PROVIDERS)]);
 function applyFixesFromProviders(issues, content, filepath) {
+    const fileIssues = issues.filter(i => i.file === filepath);
+    if (fileIssues.length === 0)
+        return content;
+    const hasAstContentRules = [
+        'redundant_progn',
+        'quote_style',
+        'redundant_if',
+        'misplaced_else',
+        'setq_multiple',
+        'append_single',
+        'cond_simplify',
+        'while_constant',
+        'redundant_cond',
+        'quote_vs_function',
+    ];
+    const needsAst = fileIssues.some(i => hasAstContentRules.includes(i.rule));
+    let ast;
+    if (needsAst) {
+        try {
+            ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
+        }
+        catch {
+            /* ignore parse errors */
+        }
+    }
+    const posToOffset = buildPosToOffset(content);
+    for (const [rule, provider] of Object.entries(CONTENT_FIX_PROVIDERS)) {
+        const ruleIssues = fileIssues.filter(i => i.rule === rule);
+        if (ruleIssues.length > 0) {
+            content = provider(ruleIssues, content, ast, posToOffset);
+        }
+    }
+    // Re-split after content fix providers may have modified content
     const lines = content.split('\n');
-    const fixedLines = new Set();
     const fixesByRule = new Map();
-    for (const iss of issues) {
-        if (iss.file !== filepath)
-            continue;
+    for (const iss of fileIssues) {
         const set = fixesByRule.get(iss.rule) || new Set();
         set.add(iss.line);
         fixesByRule.set(iss.rule, set);
     }
     for (const [rule, lineSet] of fixesByRule) {
+        if (CONTENT_FIX_PROVIDERS[rule])
+            continue;
         const provider = FIX_PROVIDERS[rule];
         if (!provider)
             continue;
@@ -191,7 +895,6 @@ function applyFixesFromProviders(issues, content, filepath) {
             const fixed = provider(lines[idx]);
             if (fixed !== lines[idx]) {
                 lines[idx] = fixed;
-                fixedLines.add(idx);
             }
         }
     }