@fimbul/wotan/src/services/default/line-switches.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.DefaultLineSwitchParser = exports.LineSwitchFilterFactory = exports.LINE_SWITCH_REGEX = void 0;
const tslib_1 = require("tslib");
const inversify_1 = require("inversify");
const ts = require("typescript");
const tsutils_1 = require("tsutils");
const ymir_1 = require("@fimbul/ymir");
exports.LINE_SWITCH_REGEX = /^ *wotan-(enable|disable)((?:-next)?-line)?( +(?:(?:[\w-]+\/)*[\w-]+ *, *)*(?:[\w-]+\/)*[\w-]+)? *$/;
let LineSwitchFilterFactory = class LineSwitchFilterFactory {
    constructor(parser) {
        this.parser = parser;
    }
    create(context) {
        const { disables, switches } = this.parseLineSwitches(context);
        return new Filter(disables, switches, context.sourceFile);
    }
    getDisabledRanges(context) {
        // remove internal `switch` property from ranges
        return new Map(Array.from(this.parseLineSwitches(context).disables, (entry) => [
            entry[0],
            entry[1].map((range) => ({ pos: range.pos, end: range.end })),
        ]));
    }
    parseLineSwitches(context) {
        var _a, _b;
        const { sourceFile, ruleNames } = context;
        let wrappedAst;
        const raw = this.parser.parse({
            sourceFile,
            getCommentAtPosition(pos) {
                const wrap = tsutils_1.getWrappedNodeAtPosition(wrappedAst !== null && wrappedAst !== void 0 ? wrappedAst : (wrappedAst = context.getWrappedAst()), pos);
                if (wrap === undefined)
                    return;
                return tsutils_1.getCommentAtPosition(sourceFile, pos, wrap.node);
            },
        });
        const lineSwitches = [];
        const result = new Map();
        for (const rawLineSwitch of raw) {
            const lineSwitch = {
                location: rawLineSwitch.location,
                enable: rawLineSwitch.enable,
                rules: [],
                outOfRange: rawLineSwitch.end <= 0 || rawLineSwitch.pos > sourceFile.end,
            };
            lineSwitches.push(lineSwitch);
            if (lineSwitch.outOfRange)
                continue;
            const rulesToSwitch = new Map();
            for (const rawRuleSwitch of rawLineSwitch.rules) {
                const ruleSwitch = {
                    location: rawRuleSwitch.location,
                    fixLocation: rawRuleSwitch.fixLocation || rawRuleSwitch.location,
                    state: 0 /* NoMatch */,
                };
                lineSwitch.rules.push(ruleSwitch);
                if (typeof rawRuleSwitch.predicate === 'string') {
                    if (ruleNames.includes(rawRuleSwitch.predicate)) {
                        if (rulesToSwitch.has(rawRuleSwitch.predicate)) {
                            ruleSwitch.state = 2 /* Redundant */;
                        }
                        else {
                            rulesToSwitch.set(rawRuleSwitch.predicate, ruleSwitch);
                            ruleSwitch.state = 1 /* NoChange */;
                        }
                    }
                }
                else {
                    const matchingNames = ruleNames.filter(makeFilterPredicate(rawRuleSwitch.predicate));
                    if (matchingNames.length !== 0) {
                        ruleSwitch.state = 2 /* Redundant */;
                        for (const rule of matchingNames) {
                            if (!rulesToSwitch.has(rule)) {
                                rulesToSwitch.set(rule, ruleSwitch);
                                ruleSwitch.state = 1 /* NoChange */;
                            }
                        }
                    }
                }
            }
            for (const [rule, ruleSwitch] of rulesToSwitch) {
                const ranges = result.get(rule);
                if (ranges === undefined) {
                    if (rawLineSwitch.enable)
                        continue; // rule is already enabled
                    result.set(rule, [{ pos: rawLineSwitch.pos, end: (_a = rawLineSwitch.end) !== null && _a !== void 0 ? _a : Infinity, switch: ruleSwitch }]);
                }
                else {
                    const last = ranges[ranges.length - 1];
                    if (last.end === Infinity) {
                        if (!rawLineSwitch.enable)
                            continue; // rule is already disabled
                        last.end = rawLineSwitch.pos;
                        if (rawLineSwitch.end !== undefined)
                            ranges.push({ pos: rawLineSwitch.end, end: Infinity, switch: ruleSwitch });
                    }
                    else if (rawLineSwitch.enable || rawLineSwitch.pos < last.end) {
                        // rule is already enabled
                        // or disabled range is nested inside the previous range
                        continue;
                    }
                    else {
                        ranges.push({
                            pos: rawLineSwitch.pos,
                            end: (_b = rawLineSwitch.end) !== null && _b !== void 0 ? _b : Infinity,
                            switch: ruleSwitch,
                        });
                    }
                }
                ruleSwitch.state = 3 /* Unused */;
            }
        }
        return { switches: lineSwitches, disables: result };
    }
};
LineSwitchFilterFactory = tslib_1.__decorate([
    inversify_1.injectable(),
    tslib_1.__metadata("design:paramtypes", [ymir_1.LineSwitchParser])
], LineSwitchFilterFactory);
exports.LineSwitchFilterFactory = LineSwitchFilterFactory;
const stateText = {
    [1 /* NoChange */](singular, mode) { return `${singular ? 'is' : 'are'} already ${mode}d`; },
    [0 /* NoMatch */](singular) { return `do${singular ? 'es' : ''}n't match any rules enabled for this file`; },
    [3 /* Unused */](singular) { return `${singular ? 'has' : 'have'} no failures to disable`; },
    [2 /* Redundant */](singular, mode) { return singular ? `was already specified in this ${mode} switch` : 'are redundant'; },
};
class Filter {
    constructor(disables, switches, sourceFile) {
        this.disables = disables;
        this.switches = switches;
        this.sourceFile = sourceFile;
    }
    filter(finding) {
        const ruleDisables = this.disables.get(finding.ruleName);
        if (ruleDisables !== undefined) {
            const { start: { position: pos }, end: { position: end } } = finding;
            for (const disabledRange of ruleDisables) {
                if (end > disabledRange.pos && pos < disabledRange.end) {
                    disabledRange.switch.state = 4 /* Used */;
                    return false;
                }
            }
        }
        return true;
    }
    reportUseless(severity) {
        const result = [];
        for (const current of this.switches) {
            const mode = current.enable ? 'enable' : 'disable';
            if (current.rules.length === 0) {
                result.push(this.createFinding(current.outOfRange
                    ? `${titlecase(mode)} switch has no effect. The specified range doesn't exits.`
                    : `${titlecase(mode)} switch doesn't specify any rule names.`, severity, current.location));
                continue;
            }
            const counts = new Array(4 /* Used */ + 1).fill(0);
            for (const rule of current.rules)
                ++counts[rule.state];
            if (counts[4 /* Used */] === 0 && (!current.enable || counts[3 /* Unused */] === 0)) {
                const errorStates = [];
                for (let state = 0 /* NoMatch */; state !== 4 /* Used */; ++state)
                    if (counts[state] !== 0)
                        errorStates.push(stateText[state](false, mode));
                result.push(this.createFinding(`${titlecase(mode)} switch has no effect. All specified rules ${join(errorStates)}.`, severity, current.location));
                continue;
            }
            for (const ruleSwitch of current.rules)
                if (ruleSwitch.location !== undefined &&
                    ruleSwitch.state !== 4 /* Used */ &&
                    (!current.enable || ruleSwitch.state !== 3 /* Unused */))
                    result.push(this.createFinding(`This rule ${stateText[ruleSwitch.state](true, mode)}.`, severity, ruleSwitch.location, ruleSwitch.fixLocation));
        }
        return result;
    }
    createPosition(pos) {
        return {
            position: pos,
            ...ts.getLineAndCharacterOfPosition(this.sourceFile, pos),
        };
    }
    createFinding(message, severity, location, fixLocation = location) {
        return {
            ruleName: 'useless-line-switch',
            severity,
            message,
            start: this.createPosition(location.pos),
            end: this.createPosition(location.end),
            fix: { replacements: [ymir_1.Replacement.delete(fixLocation.pos, fixLocation.end)] },
        };
    }
}
function titlecase(str) {
    return str.charAt(0).toUpperCase() + str.substr(1);
}
function join(parts) {
    if (parts.length === 1)
        return parts[0];
    return parts.slice(0, -1).join(', ') + ' or ' + parts[parts.length - 1];
}
function makeFilterPredicate(predicate) {
    return typeof predicate === 'function' ? predicate : (ruleName) => predicate.test(ruleName);
}
let DefaultLineSwitchParser = class DefaultLineSwitchParser {
    parse(context) {
        const { sourceFile } = context;
        const result = [];
        const commentRegex = /(\/[/*] *wotan-(enable|disable)((?:-next)?-line)?)( +(?:(?:[\w-]+\/)*[\w-]+ *, *)*(?:[\w-]+\/)*[\w-]+)? *(?:$|\*\/)/mg;
        for (let match = commentRegex.exec(sourceFile.text); match !== null; match = commentRegex.exec(sourceFile.text)) {
            const comment = context.getCommentAtPosition(match.index);
            if (comment === undefined || comment.pos !== match.index || comment.end !== match.index + match[0].length)
                continue;
            const rules = match[4] === undefined ? [{ predicate: /^/ }] : parseRules(match[4], match.index + match[1].length);
            const enable = match[2] === 'enable';
            switch (match[3]) {
                case '-line': {
                    const lineStarts = sourceFile.getLineStarts();
                    const { line } = ts.getLineAndCharacterOfPosition(sourceFile, comment.pos);
                    result.push({
                        rules,
                        enable,
                        pos: lineStarts[line],
                        // no need to switch back if there is no next line
                        end: lineStarts.length === line + 1 ? undefined : lineStarts[line + 1],
                        location: { pos: comment.pos, end: comment.end },
                    });
                    break;
                }
                case '-next-line': {
                    const lineStarts = sourceFile.getLineStarts();
                    const line = ts.getLineAndCharacterOfPosition(sourceFile, comment.pos).line + 1;
                    if (lineStarts.length === line) {
                        // there is no next line, return an out-of-range switch that can be reported
                        result.push({
                            rules,
                            enable,
                            pos: sourceFile.end + 1,
                            end: undefined,
                            location: { pos: comment.pos, end: comment.end },
                        });
                    }
                    else {
                        result.push({
                            rules,
                            enable,
                            pos: lineStarts[line],
                            // no need to switch back if there is no next line
                            end: lineStarts.length === line + 1 ? undefined : lineStarts[line + 1],
                            location: { pos: comment.pos, end: comment.end },
                        });
                    }
                    break;
                }
                default:
                    result.push({ rules, enable, pos: comment.pos, end: undefined, location: { pos: comment.pos, end: comment.end } });
            }
        }
        return result;
    }
};
DefaultLineSwitchParser = tslib_1.__decorate([
    inversify_1.injectable()
], DefaultLineSwitchParser);
exports.DefaultLineSwitchParser = DefaultLineSwitchParser;
function parseRules(raw, offset) {
    const result = [];
    const re = /(?: *, *|$)/g;
    let pos = raw.search(/[^ ]/);
    let fixPos = pos;
    for (let match = re.exec(raw);; match = re.exec(raw)) {
        result.push({
            predicate: raw.slice(pos, match.index),
            location: { pos: pos + offset, end: match.index + offset },
            // fix of first rule needs to remove the comma after it, all other rule fixes need to remove the comma before it
            fixLocation: { pos: fixPos + offset, end: (result.length === 0 ? re.lastIndex : match.index) + offset },
        });
        if (match[0].length === 0)
            break;
        pos = re.lastIndex;
        fixPos = match.index; // fix always removes the preceeding comma
    }
    return result;
}
//# sourceMappingURL=line-switches.js.map