@shivaedev/quality 0.2.0 → 0.3.0

package/src/rules/built-in.ts

@@ -1,3 +1,23 @@
+import { maxPerFile } from "./comments/max-per-file.ts";
+import { noBanner } from "./comments/no-banner.ts";
+import { noJsdoc } from "./comments/no-jsdoc.ts";
+import { noLineReference } from "./comments/no-line-reference.ts";
+import { noPrReference } from "./comments/no-pr-reference.ts";
+import { noTodo } from "./comments/no-todo.ts";
 import { maxLines } from "./max-lines.ts";
+import { biomeOverrides } from "./suppressions/biome-overrides.ts";
+import { noDoubleCast } from "./suppressions/no-double-cast.ts";
+import { noInline } from "./suppressions/no-inline.ts";
 
-export const builtInRules = [maxLines] as const;
+export const builtInRules = [
+	maxLines,
+	noJsdoc,
+	noLineReference,
+	noPrReference,
+	noBanner,
+	noTodo,
+	maxPerFile,
+	noInline,
+	noDoubleCast,
+	biomeOverrides,
+] as const;

package/src/rules/comments/kinds.ts

@@ -0,0 +1,45 @@
+import { Effect, Schema } from "effect";
+import { SUPPRESSIONS } from "../suppressions/directives.ts";
+import type { SourceComment } from "./scan.ts";
+
+export const DEFAULT_PRAGMAS: ReadonlyArray<string> = [
+	"@vitest-environment",
+	"@vitest-environment-options",
+	"@jest-environment",
+	"@jsx",
+	"@jsxFrag",
+	"@jsxImportSource",
+	"@jsxRuntime",
+];
+
+export const Pragmas = Schema.Array(Schema.String).pipe(Schema.withDecodingDefaultKey(Effect.succeed(DEFAULT_PRAGMAS)));
+
+const DIRECTIVES: ReadonlyArray<RegExp> = [
+	...SUPPRESSIONS,
+	/^@ts-/,
+	/^biome-ignore/,
+	/^(?:eslint|oxlint|stylelint)-(?:disable|enable)/,
+	/^[#@]__(?:PURE|NO_SIDE_EFFECTS)__/,
+	/^(?:c8|v8|istanbul) ignore/,
+];
+
+const TRIPLE_SLASH = /^\/\/\/\s*</;
+
+const contentOf = (comment: SourceComment): ReadonlyArray<string> => comment.body.filter((line) => line !== "");
+
+const startsWithTag = (line: string, tags: ReadonlyArray<string>): boolean =>
+	tags.some((tag) => line === tag || line.startsWith(`${tag} `) || line.startsWith(`${tag}\t`));
+
+export const textOf = (comment: SourceComment): string => comment.body.join("\n");
+
+export const isJsdoc = (comment: SourceComment): boolean => comment.kind === "block" && comment.text.startsWith("/**") && comment.text !== "/**/";
+
+export const isPragma = (comment: SourceComment, pragmas: ReadonlyArray<string>): boolean => {
+	const content = contentOf(comment);
+	return content.length > 0 && content.every((line) => startsWithTag(line, pragmas));
+};
+
+export const isDirective = (comment: SourceComment): boolean => {
+	const first = contentOf(comment)[0] ?? "";
+	return TRIPLE_SLASH.test(comment.text) || DIRECTIVES.some((directive) => directive.test(first));
+};

package/src/rules/comments/max-per-file.ts

@@ -0,0 +1,46 @@
+import { Effect, Schema } from "effect";
+import { plural } from "../../report/plural.ts";
+import { defineRule, type Finding, type SourceFile } from "../../rule.ts";
+import { isDirective, isPragma, Pragmas } from "./kinds.ts";
+import { commentsOf, type SourceComment } from "./scan.ts";
+
+const MaxPerFileOptions = Schema.Struct({
+	max: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)).pipe(Schema.withDecodingDefaultKey(Effect.succeed(2))),
+	allow: Pragmas,
+});
+
+const continues = (previous: SourceComment | undefined, comment: SourceComment): boolean =>
+	previous !== undefined &&
+	previous.kind === "line" &&
+	comment.kind === "line" &&
+	previous.ownLine &&
+	comment.ownLine &&
+	comment.line === previous.endLine + 1;
+
+const commentBlocks = (comments: ReadonlyArray<SourceComment>): ReadonlyArray<SourceComment> =>
+	comments.filter((comment, index) => !continues(comments[index - 1], comment));
+
+const overCap = (file: SourceFile, max: number, allow: ReadonlyArray<string>): ReadonlyArray<Finding> => {
+	const counted = commentsOf(file).filter((comment) => !isDirective(comment) && !isPragma(comment, allow));
+	const blocks = commentBlocks(counted);
+	const first = blocks[max];
+	return first === undefined
+		? []
+		: [
+				{
+					file: file.path,
+					line: first.line,
+					count: blocks.length - max,
+					message: `${plural(blocks.length, "comment", "comments")} against a limit of ${max}.`,
+					threshold: max,
+				},
+			];
+};
+
+export const maxPerFile = defineRule({
+	id: "comments/max-per-file",
+	description:
+		"A file that needs more than a few comments does too much, or its comments narrate the code. Delete the comments that restate the code, then split the file.",
+	options: Schema.toStandardSchemaV1(MaxPerFileOptions, { parseOptions: { errors: "all", onExcessProperty: "error" } }),
+	check: ({ options, sources }) => sources.flatMap((file) => overCap(file, options.max, options.allow)),
+});

package/src/rules/comments/no-banner.ts

@@ -0,0 +1,10 @@
+import { definePatternRule } from "./pattern-rule.ts";
+
+const DIVIDER = "[-=*#~_+/\\\\─━═┄┈]{3,}";
+
+export const noBanner = definePatternRule({
+	id: "comments/no-banner",
+	description: "Banners, dividers and regions mark a file that does several jobs. Split the file along those sections instead.",
+	patterns: [new RegExp(`^${DIVIDER}|${DIVIDER}$`, "m"), /^#(?:end)?region\b/m],
+	message: (match) => `Banner or divider: "${match}".`,
+});

package/src/rules/comments/no-jsdoc.ts

@@ -0,0 +1,18 @@
+import { Schema } from "effect";
+import { defineRule } from "../../rule.ts";
+import { isDirective, isJsdoc, isPragma, Pragmas } from "./kinds.ts";
+import { commentsOf } from "./scan.ts";
+
+const NoJsdocOptions = Schema.Struct({ allow: Pragmas });
+
+export const noJsdoc = defineRule({
+	id: "comments/no-jsdoc",
+	description: "Names and types already say what a JSDoc block repeats. Delete it, and keep a reason the code cannot show as a short // comment.",
+	options: Schema.toStandardSchemaV1(NoJsdocOptions, { parseOptions: { errors: "all", onExcessProperty: "error" } }),
+	check: ({ options, sources }) =>
+		sources.flatMap((file) =>
+			commentsOf(file)
+				.filter((comment) => isJsdoc(comment) && !isPragma(comment, options.allow) && !isDirective(comment))
+				.map((comment) => ({ file: file.path, line: comment.line, message: "JSDoc block." })),
+		),
+});

package/src/rules/comments/no-line-reference.ts

@@ -0,0 +1,11 @@
+import { definePatternRule } from "./pattern-rule.ts";
+
+const SOURCE_EXTENSION =
+	"(?:[cm]?[jt]sx?|json5?|mdx?|css|scss|less|html?|vue|svelte|astro|ya?ml|toml|sql|prisma|graphql|gql|go|rs|py|rb|java|kt|swift|sh)";
+
+export const noLineReference = definePatternRule({
+	id: "comments/no-line-reference",
+	description: "A line number goes stale with the next edit. Name the function, type, test or setting instead.",
+	patterns: [new RegExp(`[\\w./@-]*\\.${SOURCE_EXTENSION}(?::\\d+|#L\\d+)`, "i"), /(?<![\w-])lines?\s+\d+/i],
+	message: (match) => `Refers to a line: "${match}".`,
+});

package/src/rules/comments/no-pr-reference.ts

@@ -0,0 +1,13 @@
+import { definePatternRule } from "./pattern-rule.ts";
+
+export const noPrReference = definePatternRule({
+	id: "comments/no-pr-reference",
+	description: "History belongs in version control, not in the code. State the reason itself, so the comment holds without the link.",
+	patterns: [
+		/\b(?:PR|MR|pull request|merge request|issue|ticket)s?\s*#?\d+\b/i,
+		/\/(?:pull|pulls|issues|merge_requests)\/\d+/,
+		/\bGH-\d+\b/,
+		/(?<![\w&/#-])#\d+\b/,
+	],
+	message: (match) => `Refers to a pull request or issue: "${match}".`,
+});

package/src/rules/comments/no-todo.ts

@@ -0,0 +1,8 @@
+import { definePatternRule } from "./pattern-rule.ts";
+
+export const noTodo = definePatternRule({
+	id: "comments/no-todo",
+	description: "A TODO in the code is never done. Do the work now, or track it where the repository tracks work.",
+	patterns: [/\b(?:TODO|FIXME|XXX)\b/, /@todo\b/i],
+	message: (match) => `Marks unfinished work: "${match}".`,
+});

package/src/rules/comments/pattern-rule.ts

@@ -0,0 +1,28 @@
+import { defineRule, type Finding, type Rule } from "../../rule.ts";
+import { isDirective, textOf } from "./kinds.ts";
+import { commentsOf, type SourceComment } from "./scan.ts";
+
+interface PatternRule<Id extends string> {
+	readonly id: Id;
+	readonly description: string;
+	readonly patterns: ReadonlyArray<RegExp>;
+	readonly message: (match: string) => string;
+}
+
+const firstMatch = (comment: SourceComment, patterns: ReadonlyArray<RegExp>): string | undefined => {
+	const text = textOf(comment);
+	return patterns.map((pattern) => pattern.exec(text)?.[0]).find((match) => match !== undefined);
+};
+
+export const definePatternRule = <const Id extends string>({ description, id, message, patterns }: PatternRule<Id>): Rule<Id, undefined> =>
+	defineRule({
+		id,
+		description,
+		check: ({ sources }) =>
+			sources.flatMap((file) =>
+				commentsOf(file).flatMap((comment): ReadonlyArray<Finding> => {
+					const match = isDirective(comment) ? undefined : firstMatch(comment, patterns);
+					return match === undefined ? [] : [{ file: file.path, line: comment.line, message: message(match) }];
+				}),
+			),
+	});

package/src/rules/comments/scan.ts

@@ -0,0 +1,80 @@
+import ts from "typescript";
+import type { SourceFile } from "../../rule.ts";
+import { parse } from "../syntax.ts";
+
+export interface SourceComment {
+	readonly kind: "block" | "line";
+	readonly text: string;
+	readonly body: ReadonlyArray<string>;
+	readonly line: number;
+	readonly endLine: number;
+	readonly ownLine: boolean;
+}
+
+const DECLARATION = /\.d\.[cm]?ts$/;
+
+const commentRanges = (source: ts.SourceFile): ReadonlyArray<ts.CommentRange> => {
+	const ranges = new Map<number, ts.CommentRange>();
+	const jsxText: Array<ts.Node> = [];
+	const add = (found: ReadonlyArray<ts.CommentRange> | undefined) => {
+		for (const range of found ?? []) {
+			ranges.set(range.pos, range);
+		}
+	};
+	const visit = (node: ts.Node) => {
+		if (node.kind === ts.SyntaxKind.JsxText) {
+			jsxText.push(node);
+		}
+		add(ts.getLeadingCommentRanges(source.text, node.pos));
+		add(ts.getTrailingCommentRanges(source.text, node.end));
+		for (const child of node.getChildren(source)) {
+			visit(child);
+		}
+	};
+	visit(source);
+	return [...ranges.values()]
+		.filter((range) => !jsxText.some((text) => range.pos >= text.pos && range.pos < text.end))
+		.sort((left, right) => left.pos - right.pos);
+};
+
+export const bodyOf = (kind: SourceComment["kind"], text: string): ReadonlyArray<string> =>
+	kind === "line"
+		? [text.slice(2).trim()]
+		: text
+				.slice(2, -2)
+				.split("\n")
+				.map((line) => line.trim().replace(/^\*(?=\s|$)\s*/, ""));
+
+const toComment = (source: ts.SourceFile, range: ts.CommentRange): SourceComment => {
+	const kind = range.kind === ts.SyntaxKind.SingleLineCommentTrivia ? "line" : "block";
+	const text = source.text.slice(range.pos, range.end);
+	const start = source.getLineAndCharacterOfPosition(range.pos);
+	const lineStart = source.getPositionOfLineAndCharacter(start.line, 0);
+	return {
+		body: bodyOf(kind, text),
+		endLine: source.getLineAndCharacterOfPosition(range.end).line + 1,
+		kind,
+		line: start.line + 1,
+		ownLine: source.text.slice(lineStart, range.pos).trim() === "",
+		text,
+	};
+};
+
+const scanned = new WeakMap<SourceFile, ReadonlyArray<SourceComment>>();
+
+const scan = (file: SourceFile): ReadonlyArray<SourceComment> => {
+	const source = parse(file);
+	return source === undefined ? [] : commentRanges(source).map((range) => toComment(source, range));
+};
+
+export const scanComments = (file: SourceFile): ReadonlyArray<SourceComment> => {
+	const cached = scanned.get(file);
+	if (cached !== undefined) {
+		return cached;
+	}
+	const comments = scan(file);
+	scanned.set(file, comments);
+	return comments;
+};
+
+export const commentsOf = (file: SourceFile): ReadonlyArray<SourceComment> => (DECLARATION.test(file.path) ? [] : scanComments(file));

package/src/rules/max-lines.ts

@@ -16,7 +16,14 @@ const MaxLinesOptions = Schema.Struct({
 const oversized = (file: SourceFile, limit: number): ReadonlyArray<Finding> =>
 	file.lines.length <= limit
 		? []
-		: [{ file: file.path, measure: file.lines.length, message: `${file.lines.length} lines exceeds the ${limit}-line limit.` }];
+		: [
+				{
+					count: file.lines.length - limit,
+					file: file.path,
+					message: `${file.lines.length} lines exceeds the ${limit}-line limit.`,
+					threshold: limit,
+				},
+			];
 
 export const maxLines = defineRule({
 	id: "structure/max-lines",

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

@@ -0,0 +1,50 @@
+import { posix } from "node:path";
+import type { RuleInputs } from "../../../rule.ts";
+import { itemsOf, type Json, member, parseJsonc, textOf } from "./json.ts";
+
+export type Config =
+	| { readonly _tag: "Config"; readonly path: string; readonly base: string; readonly json: Json }
+	| { readonly _tag: "Unreadable"; readonly path: string; readonly reason: string };
+
+const ROOT_CONFIGS: ReadonlyArray<string> = ["biome.json", "biome.jsonc"];
+
+const NESTED = /(?:^|\/)biome\.jsonc?$/;
+
+const directoryOf = (path: string): string => (posix.dirname(path) === "." ? "" : posix.dirname(path));
+
+const localExtends = (path: string, json: Json): ReadonlyArray<string> => {
+	const node = member(json, "extends");
+	const entries = node?._tag === "Array" ? itemsOf(node).flatMap((item) => textOf(item) ?? []) : [textOf(node) ?? ""];
+	return entries.filter((entry) => entry.startsWith(".")).map((entry) => posix.join(posix.dirname(path), entry));
+};
+
+const load = async (readText: RuleInputs["readText"], path: string, base: string, seen: Set<string>): Promise<ReadonlyArray<Config>> => {
+	if (seen.has(path)) {
+		return [];
+	}
+	seen.add(path);
+	const text = await readText(path);
+	if (text === undefined) {
+		return [{ _tag: "Unreadable", path, reason: "the file does not exist" }];
+	}
+	const parsed = parseJsonc(path, text);
+	if (parsed._tag === "Unreadable") {
+		return [{ _tag: "Unreadable", path, reason: parsed.reason }];
+	}
+	const extended = await Promise.all(localExtends(path, parsed.json).map((target) => load(readText, target, base, seen)));
+	return [{ _tag: "Config", base, json: parsed.json, path }, ...extended.flat()];
+};
+
+const rootConfig = async (readText: RuleInputs["readText"]): Promise<string | undefined> => {
+	const present = await Promise.all(ROOT_CONFIGS.map(async (path) => ((await readText(path)) === undefined ? [] : [path])));
+	return present.flat()[0];
+};
+
+export const biomeConfigs = async ({ files, readText }: RuleInputs): Promise<ReadonlyArray<Config>> => {
+	const seen = new Set<string>();
+	const root = await rootConfig(readText);
+	const nested = files.filter((path) => NESTED.test(path) && path !== root);
+	const roots = root === undefined ? [] : await load(readText, root, "", seen);
+	const below = await Promise.all(nested.map((path) => load(readText, path, directoryOf(path), seen)));
+	return [...roots, ...below.flat()];
+};

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

@@ -0,0 +1,55 @@
+import ts from "typescript";
+
+export type Json =
+	| { readonly _tag: "Object"; readonly line: number; readonly entries: ReadonlyMap<string, Json> }
+	| { readonly _tag: "Array"; readonly line: number; readonly items: ReadonlyArray<Json> }
+	| { readonly _tag: "Value"; readonly line: number; readonly value: string | boolean | undefined };
+
+export type Parsed = { readonly _tag: "Parsed"; readonly json: Json } | { readonly _tag: "Unreadable"; readonly reason: string };
+
+const LITERALS: ReadonlyMap<ts.SyntaxKind, boolean> = new Map([
+	[ts.SyntaxKind.TrueKeyword, true],
+	[ts.SyntaxKind.FalseKeyword, false],
+]);
+
+const scalarOf = (node: ts.Expression): string | boolean | undefined => (ts.isStringLiteral(node) ? node.text : LITERALS.get(node.kind));
+
+const entryOf = (source: ts.JsonSourceFile, property: ts.ObjectLiteralElementLike): ReadonlyArray<readonly [string, Json]> =>
+	ts.isPropertyAssignment(property) && (ts.isStringLiteral(property.name) || ts.isIdentifier(property.name))
+		? [[property.name.text, toJson(source, property.initializer)]]
+		: [];
+
+const toJson = (source: ts.JsonSourceFile, node: ts.Expression): Json => {
+	const line = source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1;
+	if (ts.isObjectLiteralExpression(node)) {
+		return { _tag: "Object", entries: new Map(node.properties.flatMap((property) => entryOf(source, property))), line };
+	}
+	if (ts.isArrayLiteralExpression(node)) {
+		return { _tag: "Array", items: node.elements.map((element) => toJson(source, element)), line };
+	}
+	return { _tag: "Value", line, value: scalarOf(node) };
+};
+
+export const parseJsonc = (path: string, text: string): Parsed => {
+	const error = ts.parseConfigFileTextToJson(path, text).error;
+	const source = ts.parseJsonText(path, text);
+	const root = source.statements[0]?.expression;
+	if (error !== undefined || root === undefined) {
+		return {
+			_tag: "Unreadable",
+			reason: error === undefined ? "it is empty" : ts.flattenDiagnosticMessageText(error.messageText, " ").replace(/\.$/, ""),
+		};
+	}
+	return { _tag: "Parsed", json: toJson(source, root) };
+};
+
+export const member = (node: Json | undefined, key: string): Json | undefined => (node?._tag === "Object" ? node.entries.get(key) : undefined);
+
+export const entriesOf = (node: Json | undefined): ReadonlyArray<readonly [string, Json]> => (node?._tag === "Object" ? [...node.entries] : []);
+
+export const itemsOf = (node: Json | undefined): ReadonlyArray<Json> => (node?._tag === "Array" ? node.items : []);
+
+export const textOf = (node: Json | undefined): string | undefined =>
+	node?._tag === "Value" && typeof node.value === "string" ? node.value : undefined;
+
+export const isFalse = (node: Json | undefined): boolean => node?._tag === "Value" && node.value === false;

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),
+});