@shivaedev/quality 0.2.0 → 0.3.1

package/src/rules/suppressions/biome/weakenings.ts

@@ -0,0 +1,102 @@
+import { entriesOf, isFalse, itemsOf, type Json, member, textOf } from "./json.ts";
+
+export interface Weakening {
+	readonly rule: string;
+	readonly includes: ReadonlyArray<string>;
+	readonly file: string;
+	readonly line: number;
+}
+
+interface Setting {
+	readonly rule: string;
+	readonly line: number;
+}
+
+const LINT_WEAK = new Set(["off", "warn", "info"]);
+const ASSIST_WEAK = new Set(["off"]);
+const PRESETS = new Set(["recommended", "preset"]);
+
+const levelOf = (node: Json): string | undefined => textOf(node) ?? textOf(member(node, "level"));
+
+const at = (rule: string, node: Json | undefined): ReadonlyArray<Setting> => (node === undefined ? [] : [{ line: node.line, rule }]);
+
+const disabled = (rule: string, section: Json | undefined): ReadonlyArray<Setting> =>
+	isFalse(member(section, "enabled")) ? at(rule, member(section, "enabled")) : [];
+
+const withoutDefaults = (rule: string, set: Json | undefined): ReadonlyArray<Setting> => [
+	...(isFalse(member(set, "recommended")) ? at(rule, member(set, "recommended")) : []),
+	...(textOf(member(set, "preset")) === "none" ? at(rule, member(set, "preset")) : []),
+];
+
+const groupSettings = (prefix: string, weak: ReadonlySet<string>, groups: Json | undefined): ReadonlyArray<Setting> =>
+	entriesOf(groups)
+		.filter(([group]) => !PRESETS.has(group))
+		.flatMap(([group, rules]) => [
+			...(weak.has(textOf(rules) ?? "") ? at(`${prefix}/${group}`, rules) : []),
+			...withoutDefaults(`${prefix}/${group}`, rules),
+			...entriesOf(rules)
+				.filter(([rule, setting]) => !PRESETS.has(rule) && weak.has(levelOf(setting) ?? ""))
+				.flatMap(([rule, setting]) => at(`${prefix}/${group}/${rule}`, setting)),
+		]);
+
+const linter = (section: Json | undefined): ReadonlyArray<Setting> => [
+	...disabled("lint", section),
+	...withoutDefaults("lint/recommended", member(section, "rules")),
+	...groupSettings("lint", LINT_WEAK, member(section, "rules")),
+	...entriesOf(member(section, "domains"))
+		.filter(([, value]) => textOf(value) === "none")
+		.flatMap(([domain, value]) => at(`lint/domains/${domain}`, value)),
+];
+
+const assist = (section: Json | undefined): ReadonlyArray<Setting> => [
+	...disabled("assist", section),
+	...withoutDefaults("assist/recommended", member(section, "actions")),
+	...groupSettings("assist", ASSIST_WEAK, member(section, "actions")),
+];
+
+const LANGUAGES: ReadonlyArray<string> = ["javascript", "json", "css", "graphql", "grit", "html"];
+
+const TOOLS: ReadonlyArray<readonly [string, string]> = [
+	["linter", "lint"],
+	["assist", "assist"],
+	["formatter", "format"],
+];
+
+const SCOPED_SECTIONS: ReadonlyArray<readonly [string, string]> = [["files", "files"], ...TOOLS];
+
+const scopeSettings = (scope: Json): ReadonlyArray<Setting> => [
+	...linter(member(scope, "linter")),
+	...assist(member(scope, "assist")),
+	...disabled("format", member(scope, "formatter")),
+	...LANGUAGES.flatMap((language) => TOOLS.flatMap(([key, name]) => disabled(`${language}/${name}`, member(member(scope, language), key)))),
+];
+
+const scoped = (base: string, glob: string): string => {
+	const [, negation = "", path = glob] = /^(!*)(.*)$/.exec(glob) ?? [];
+	return base === "" ? glob : `${negation}${base}/${path}`;
+};
+
+const includesOf = (override: Json): ReadonlyArray<string> => {
+	const includes = itemsOf(member(override, "includes")).flatMap((item) => textOf(item) ?? []);
+	return includes.length === 0 ? ["**"] : includes;
+};
+
+const narrowsScope = (globs: ReadonlyArray<string>): boolean =>
+	globs.length > 0 && (globs.some((glob) => glob.startsWith("!")) || !globs.includes("**"));
+
+const narrowings = (config: Json, file: string, base: string): ReadonlyArray<Weakening> =>
+	SCOPED_SECTIONS.flatMap(([key, name]) => {
+		const list = member(member(config, key), "includes");
+		const globs = itemsOf(list).flatMap((item) => textOf(item) ?? []);
+		return list === undefined || !narrowsScope(globs)
+			? []
+			: [{ file, includes: globs.map((glob) => scoped(base, glob)), line: list.line, rule: `${name}/includes` }];
+	});
+
+export const weakeningsOf = (config: Json, file: string, base: string): ReadonlyArray<Weakening> => [
+	...narrowings(config, file, base),
+	...scopeSettings(config).map((setting) => ({ ...setting, file, includes: [scoped(base, "**")] })),
+	...itemsOf(member(config, "overrides")).flatMap((override) =>
+		scopeSettings(override).map((setting) => ({ ...setting, file, includes: includesOf(override).map((glob) => scoped(base, glob)) })),
+	),
+];

package/src/rules/suppressions/biome-overrides.ts

@@ -0,0 +1,61 @@
+import { Effect, Schema } from "effect";
+import { defineRule, type Finding } from "../../rule.ts";
+import { biomeConfigs, type Config } from "./biome/configs.ts";
+import { type Weakening, weakeningsOf } from "./biome/weakenings.ts";
+
+const Declaration = Schema.Struct({
+	rule: Schema.NonEmptyString,
+	includes: Schema.NonEmptyArray(Schema.NonEmptyString),
+	reason: Schema.String.check(Schema.isPattern(/\S/, { expected: "a reason that says why the scope needs the rule weakened" })),
+});
+
+type Declaration = typeof Declaration.Type;
+
+const BiomeOverridesOptions = Schema.Struct({
+	declared: Schema.Array(Declaration).pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),
+});
+
+const sameScope = (left: ReadonlyArray<string>, right: ReadonlyArray<string>): boolean =>
+	new Set(left).size === new Set(right).size && left.every((glob) => right.includes(glob));
+
+const matches = (declaration: Declaration, weakening: Weakening): boolean =>
+	declaration.rule === weakening.rule && sameScope(declaration.includes, weakening.includes);
+
+const scopeText = (includes: ReadonlyArray<string>): string => includes.map((glob) => `"${glob}"`).join(", ");
+
+const undeclared = (weakening: Weakening): Finding => ({
+	file: weakening.file,
+	line: weakening.line,
+	message: `Weakens "${weakening.rule}" for ${scopeText(weakening.includes)} without a declaration.`,
+	subject: weakening.rule,
+});
+
+const unused = (file: string, declaration: Declaration): Finding => ({
+	file,
+	message: `Declares "${declaration.rule}" for ${scopeText(declaration.includes)}, which no Biome config weakens. Remove the declaration.`,
+	subject: declaration.rule,
+});
+
+const unreadable = (config: Config): ReadonlyArray<Finding> =>
+	config._tag === "Unreadable" ? [{ file: config.path, message: `Cannot read this Biome config: ${config.reason}.` }] : [];
+
+export const biomeOverrides = defineRule({
+	id: "suppressions/biome-overrides",
+	description:
+		"A Biome setting that turns a check off or down, or keeps files out of it, is an exception for every file it covers. Fix the code and remove the setting, or declare its rule, includes and reason under this rule's declared option.",
+	options: Schema.toStandardSchemaV1(BiomeOverridesOptions, { parseOptions: { errors: "all", onExcessProperty: "error" } }),
+	registrable: false,
+	check: async (inputs) => {
+		const configs = await biomeConfigs(inputs);
+		const { declared } = inputs.options;
+		const weakenings = configs.flatMap((config) => (config._tag === "Config" ? weakeningsOf(config.json, config.path, config.base) : []));
+		const root = configs.find((config) => !config.path.includes("/"))?.path ?? "biome.json";
+		return [
+			...configs.flatMap(unreadable),
+			...weakenings.filter((weakening) => !declared.some((declaration) => matches(declaration, weakening))).map(undeclared),
+			...declared
+				.filter((declaration) => !weakenings.some((weakening) => matches(declaration, weakening)))
+				.map((declaration) => unused(root, declaration)),
+		];
+	},
+});

package/src/rules/suppressions/directives.ts

@@ -0,0 +1,25 @@
+import type { SourceComment } from "../comments/scan.ts";
+
+export const SUPPRESSIONS: ReadonlyArray<RegExp> = [
+	/^biome-ignore(?:-all|-start)?(?![\w-])/,
+	/^@ts-(?:ignore|expect-error|nocheck)(?![\w-])/,
+	/^(?:eslint|oxlint|stylelint)-disable(?:-next-line|-line)?(?![\w-])/,
+	/^deno-lint-ignore(?:-file)?(?![\w-])/,
+	/^tslint:disable/,
+	/^prettier-ignore(?![\w-])/,
+	/^\$Flow(?:FixMe|Ignore|ExpectedError|Issue)(?!\w)/,
+	/^@noflow(?!\w)/,
+];
+
+const INLINE_ESLINT_CONFIG = /^eslint\s+["']?[\w@/-]+["']?\s*:/;
+
+const LEADER = /^[\s/*]+/;
+
+const directiveOn = (comment: SourceComment, line: string): string | undefined => {
+	const content = line.replace(LEADER, "");
+	const patterns = comment.kind === "block" ? [...SUPPRESSIONS, INLINE_ESLINT_CONFIG] : SUPPRESSIONS;
+	return patterns.map((pattern) => pattern.exec(content)?.[0].replace(/\s*:$/, "")).find((match) => match !== undefined);
+};
+
+export const suppressionIn = (comment: SourceComment): string | undefined =>
+	comment.body.map((line) => directiveOn(comment, line)).find((directive) => directive !== undefined);

package/src/rules/suppressions/no-double-cast.ts

@@ -0,0 +1,47 @@
+import ts from "typescript";
+import { defineRule, type Finding, type SourceFile } from "../../rule.ts";
+import { parse } from "../syntax.ts";
+
+const BRIDGES: ReadonlyMap<ts.SyntaxKind, string> = new Map([
+	[ts.SyntaxKind.UnknownKeyword, "unknown"],
+	[ts.SyntaxKind.AnyKeyword, "any"],
+	[ts.SyntaxKind.NeverKeyword, "never"],
+]);
+
+type Assertion = ts.AsExpression | ts.TypeAssertion;
+
+const isAssertion = (node: ts.Node): node is Assertion => ts.isAsExpression(node) || ts.isTypeAssertionExpression(node);
+
+const unwrapped = (node: ts.Expression): ts.Expression => (ts.isParenthesizedExpression(node) ? unwrapped(node.expression) : node);
+
+const bridgeOf = (node: Assertion): string | undefined => {
+	const inner = unwrapped(node.expression);
+	return isAssertion(inner) ? BRIDGES.get(inner.type.kind) : undefined;
+};
+
+const castsIn = (path: string, source: ts.SourceFile): ReadonlyArray<Finding> => {
+	const findings: Finding[] = [];
+	const visit = (node: ts.Node): void => {
+		const bridge = isAssertion(node) ? bridgeOf(node) : undefined;
+		if (bridge !== undefined) {
+			const line = source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1;
+			findings.push({ file: path, line, message: `Casts through "${bridge}" to reach a type the value does not have.` });
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(source);
+	return findings;
+};
+
+const doubleCasts = (file: SourceFile): ReadonlyArray<Finding> => {
+	const source = parse(file);
+	return source === undefined ? [] : castsIn(file.path, source);
+};
+
+export const noDoubleCast = defineRule({
+	id: "suppressions/no-double-cast",
+	description:
+		"A cast through unknown, any or never silences the compiler the way a suppression does. Decode the value at its boundary, narrow it, or fix the type that disagrees.",
+	registrable: false,
+	check: ({ sources }) => sources.flatMap(doubleCasts),
+});

package/src/rules/suppressions/no-inline.ts

@@ -0,0 +1,63 @@
+import { Effect, Schema } from "effect";
+import ignore from "ignore";
+import { CONFIG_FILE } from "../../config/file.ts";
+import { defineRule, type Finding, type RuleInputs } from "../../rule.ts";
+import { type SourceComment, scanComments } from "../comments/scan.ts";
+import { suppressionIn } from "./directives.ts";
+import { STYLESHEET, stylesheetComments } from "./stylesheet-comments.ts";
+
+const Declaration = Schema.Struct({
+	directive: Schema.Literal("@ts-expect-error"),
+	includes: Schema.NonEmptyArray(Schema.NonEmptyString),
+	reason: Schema.String.check(Schema.isPattern(/\S/, { expected: "a reason that says why these files assert type errors" })),
+});
+
+type Declaration = typeof Declaration.Type;
+
+const NoInlineOptions = Schema.Struct({
+	declared: Schema.Array(Declaration).pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),
+});
+
+interface Site extends Finding {
+	readonly subject: string;
+}
+
+const sitesIn = (file: string, comments: ReadonlyArray<SourceComment>): ReadonlyArray<Site> =>
+	comments.flatMap((comment) => {
+		const directive = suppressionIn(comment);
+		return directive === undefined ? [] : [{ file, line: comment.line, message: `Suppresses a check: "${directive}".`, subject: directive }];
+	});
+
+const stylesheetSites = async ({ files, readText, sources }: RuleInputs): Promise<ReadonlyArray<Site>> => {
+	const read = files.filter((path) => STYLESHEET.test(path));
+	const texts = await Promise.all(read.map(async (path) => sources.find((source) => source.path === path)?.text ?? (await readText(path))));
+	return read.flatMap((path, index) => sitesIn(path, stylesheetComments(path, texts[index] ?? "")));
+};
+
+const allows = (declaration: Declaration, site: Site): boolean =>
+	declaration.directive === site.subject &&
+	ignore()
+		.add([...declaration.includes])
+		.ignores(site.file);
+
+const unused = (declaration: Declaration): Finding => ({
+	file: CONFIG_FILE,
+	message: `Declares "${declaration.directive}" for ${declaration.includes.map((glob) => `"${glob}"`).join(", ")}, which matches no directive. Remove the declaration.`,
+	subject: declaration.directive,
+});
+
+export const noInline = defineRule({
+	id: "suppressions/no-inline",
+	description:
+		"A suppression silences a check at one site instead of fixing the cause. Fix the code; where a lint rule truly cannot apply, turn it off for that scope in the Biome config and declare it under suppressions/biome-overrides.",
+	options: Schema.toStandardSchemaV1(NoInlineOptions, { parseOptions: { errors: "all", onExcessProperty: "error" } }),
+	registrable: false,
+	check: async (inputs) => {
+		const { declared } = inputs.options;
+		const sites = [...inputs.sources.flatMap((file) => sitesIn(file.path, scanComments(file))), ...(await stylesheetSites(inputs))];
+		return [
+			...sites.filter((site) => !declared.some((declaration) => allows(declaration, site))),
+			...declared.filter((declaration) => !sites.some((site) => allows(declaration, site))).map(unused),
+		];
+	},
+});

package/src/rules/suppressions/stylesheet-comments.ts

@@ -0,0 +1,27 @@
+import { bodyOf, type SourceComment } from "../comments/scan.ts";
+
+export const STYLESHEET = /\.(?:css|scss|less)$/;
+
+const LINE_COMMENTS = /\.(?:scss|less)$/;
+
+const TOKENS = String.raw`"(?:[^"\\\n]|\\.)*"?|'(?:[^'\\\n]|\\.)*'?|url\([^)]*\)?|\/\*[\s\S]*?(?:\*\/|$)`;
+
+const tokensOf = (path: string): RegExp => new RegExp(LINE_COMMENTS.test(path) ? `${TOKENS}|\\/\\/[^\\n]*` : TOKENS, "gi");
+
+const lineOf = (text: string, offset: number): number => text.slice(0, offset).split("\n").length;
+
+const toComment = (text: string, token: string, offset: number): SourceComment => {
+	const kind = token.startsWith("//") ? "line" : "block";
+	const lineStart = text.lastIndexOf("\n", offset - 1) + 1;
+	return {
+		body: bodyOf(kind, kind === "block" && !token.endsWith("*/") ? `${token}*/` : token),
+		endLine: lineOf(text, offset + token.length),
+		kind,
+		line: lineOf(text, offset),
+		ownLine: text.slice(lineStart, offset).trim() === "",
+		text: token,
+	};
+};
+
+export const stylesheetComments = (path: string, text: string): ReadonlyArray<SourceComment> =>
+	[...text.matchAll(tokensOf(path))].flatMap((match) => (match[0].startsWith("/") ? [toComment(text, match[0], match.index)] : []));

package/src/rules/syntax.ts

@@ -0,0 +1,14 @@
+import ts from "typescript";
+import type { SourceFile } from "../rule.ts";
+
+const SCRIPT_KINDS: ReadonlyArray<readonly [RegExp, ts.ScriptKind]> = [
+	[/\.[cm]?ts$/, ts.ScriptKind.TS],
+	[/\.tsx$/, ts.ScriptKind.TSX],
+	[/\.[cm]?js$/, ts.ScriptKind.JS],
+	[/\.jsx$/, ts.ScriptKind.JSX],
+];
+
+export const parse = (file: SourceFile): ts.SourceFile | undefined => {
+	const kind = SCRIPT_KINDS.find(([pattern]) => pattern.test(file.path))?.[1];
+	return kind === undefined ? undefined : ts.createSourceFile(file.path, file.text, ts.ScriptTarget.Latest, true, kind);
+};