@rigour-labs/core 6.7.1 → 6.7.4

package/dist/review/typed/constant-inputs.js

@@ -0,0 +1,168 @@
+import { isTestFile } from '../test-files.js';
+export function constantInputs(typed, changedSources, declared, h) {
+    constantMembers(typed, declared, h);
+    constantArguments(typed, changedSources, h);
+}
+/** A literal's value as text (`0`, `'a'`, `true`, `null`), or undefined for anything computed. */
+function literal(ts, node) {
+    if (!node)
+        return undefined;
+    if (ts.isNumericLiteral(node) || ts.isStringLiteralLike(node))
+        return `${ts.isNumericLiteral(node) ? '' : "'"}${node.text}${ts.isNumericLiteral(node) ? '' : "'"}`;
+    if (node.kind === ts.SyntaxKind.TrueKeyword)
+        return 'true';
+    if (node.kind === ts.SyntaxKind.FalseKeyword)
+        return 'false';
+    if (node.kind === ts.SyntaxKind.NullKeyword)
+        return 'null';
+    if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(node.operand))
+        return `-${node.operand.text}`;
+    return undefined;
+}
+/** The access is tested: an `if`/ternary/`while` condition, a comparison, `!`, `&&`/`||`, or a `switch`. */
+function inCondition(ts, node) {
+    for (let n = node, p = node.parent; p; n = p, p = p.parent) {
+        if ((ts.isIfStatement(p) || ts.isWhileStatement(p) || ts.isConditionalExpression(p)) && p.expression === n)
+            return true;
+        if (ts.isConditionalExpression(p) && p.condition === n)
+            return true;
+        if (ts.isSwitchStatement(p) && p.expression === n)
+            return true;
+        if (ts.isBinaryExpression(p) && [ts.SyntaxKind.GreaterThanToken, ts.SyntaxKind.LessThanToken, ts.SyntaxKind.GreaterThanEqualsToken, ts.SyntaxKind.LessThanEqualsToken, ts.SyntaxKind.EqualsEqualsToken, ts.SyntaxKind.EqualsEqualsEqualsToken, ts.SyntaxKind.ExclamationEqualsToken, ts.SyntaxKind.ExclamationEqualsEqualsToken, ts.SyntaxKind.AmpersandAmpersandToken, ts.SyntaxKind.BarBarToken].includes(p.operatorToken.kind)) {
+            if (ts.isIfStatement(p.parent) || ts.isConditionalExpression(p.parent) || ts.isBinaryExpression(p.parent) || ts.isPrefixUnaryExpression(p.parent) || ts.isReturnStatement(p.parent))
+                return true;
+            continue;
+        }
+        if (ts.isPrefixUnaryExpression(p) && p.operator === ts.SyntaxKind.ExclamationToken)
+            continue;
+        if (ts.isParenthesizedExpression(p))
+            continue;
+        return false;
+    }
+    return false;
+}
+function constantMembers(typed, declared, h) {
+    const { ts, checker } = typed;
+    for (const t of declared) {
+        const hosts = h.hostsOf(t).filter(host => !isTestFile(h.rel(host.getSourceFile())));
+        if (hosts.length < 2 || hosts.some(host => host.properties.some(p => ts.isSpreadAssignment(p))))
+            continue;
+        for (const m of t.members) {
+            const name = m.name.getText();
+            const values = hosts.map(host => {
+                const p = host.properties.find(q => q.name && ts.isIdentifier(q.name) && q.name.text === name);
+                return p && ts.isPropertyAssignment(p) ? literal(ts, p.initializer) : undefined;
+            });
+            if (values.some(v => v === undefined) || new Set(values).size !== 1)
+                continue;
+            const anchor = h.touched(m) ? m : hosts.every(h.spanTouched) ? hosts.find(h.spanTouched) : undefined;
+            if (!anchor)
+                continue;
+            const sym = checker.getPropertyOfType(t.type, name);
+            const tested = sym && findReads(typed, sym, h).find(read => inCondition(ts, read));
+            if (!tested)
+                continue;
+            h.report('constant-member', 'A member every production object sets to the same value', anchor, `\`${t.name}.${name}\` is ${values[0]} in all ${hosts.length} production objects of the type (e.g. ${h.at(hosts[0])}), yet ${h.at(tested)} branches on it: the other branches never run outside tests.`, `Delete the branches and the member, or pass the real value where the objects are built.`);
+        }
+    }
+}
+/** Every non-test read of the property symbol. */
+function findReads(typed, sym, h) {
+    const { ts, checker } = typed;
+    const decl = sym.declarations?.[0];
+    const reads = [];
+    for (const sf of typed.appSources) {
+        if (isTestFile(h.rel(sf)) || !sf.text.includes(sym.name))
+            continue;
+        h.walk(sf, node => {
+            if (!ts.isPropertyAccessExpression(node) || node.name.text !== sym.name)
+                return;
+            const s = checker.getSymbolAtLocation(node.name);
+            if (s && (s === sym || s.declarations?.[0] === decl))
+                reads.push(node);
+        });
+    }
+    return reads;
+}
+function constantArguments(typed, changedSources, h) {
+    const { ts, checker } = typed;
+    // Functions the change declared, by declaration node.
+    const functions = [];
+    for (const sf of changedSources) {
+        h.walk(sf, node => {
+            if (ts.isFunctionDeclaration(node) && node.name && node.body && node.parameters.length)
+                functions.push(node);
+            else if ((ts.isArrowFunction(node) || ts.isFunctionExpression(node)) && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name) && node.parameters.length)
+                functions.push(node);
+        });
+    }
+    if (functions.length === 0)
+        return;
+    const wanted = new Set(functions);
+    const calls = new Map();
+    // Tests included: a test passing another value is the evidence a production-only constant is a test seam.
+    for (const sf of typed.program.getSourceFiles().filter(f => !f.isDeclarationFile && !f.fileName.includes('/node_modules/'))) {
+        const test = isTestFile(h.rel(sf));
+        h.walk(sf, node => {
+            if (!ts.isCallExpression(node))
+                return;
+            const decl = checker.getResolvedSignature(node)?.declaration;
+            if (!decl || !wanted.has(decl))
+                return;
+            const entry = calls.get(decl) ?? { prod: [], test: [] };
+            (test ? entry.test : entry.prod).push(node);
+            calls.set(decl, entry);
+        });
+    }
+    // A function handed around as a value (a callback, an export others call dynamically) has callers the checker cannot list.
+    const passedAsValue = (fn) => {
+        const name = ts.isFunctionDeclaration(fn) ? fn.name : ts.isVariableDeclaration(fn.parent) ? fn.parent.name : undefined;
+        if (!name || !ts.isIdentifier(name))
+            return true;
+        const sym = checker.getSymbolAtLocation(name);
+        let escaped = false;
+        for (const sf of typed.appSources) {
+            if (escaped || !sf.text.includes(name.text))
+                continue;
+            h.walk(sf, node => {
+                if (escaped || !ts.isIdentifier(node) || node.text !== name.text || node === name)
+                    return;
+                if (checker.getSymbolAtLocation(node) !== sym)
+                    return;
+                const p = node.parent;
+                const called = ts.isCallExpression(p) && p.expression === node;
+                const imported = ts.isImportSpecifier(p) || ts.isExportSpecifier(p) || ts.isImportClause(p);
+                if (!called && !imported)
+                    escaped = true;
+            });
+        }
+        return escaped;
+    };
+    for (const fn of functions) {
+        const entry = calls.get(fn);
+        if (!entry || entry.prod.length < 2 || passedAsValue(fn) || !fn.body)
+            continue;
+        fn.parameters.forEach((param, i) => {
+            if (param.dotDotDotToken || !ts.isIdentifier(param.name))
+                return;
+            // Literals only: two calls passing a variable of the same name do not pass the same value.
+            const texts = entry.prod.map(c => (c.arguments[i] ? literal(ts, c.arguments[i]) : 'undefined'));
+            if (texts.some(t => t === undefined) || new Set(texts).size !== 1)
+                return;
+            // Proof of dead code: the body branches on the parameter, and production only ever takes one side.
+            const paramSym = checker.getSymbolAtLocation(param.name);
+            let tested;
+            h.walk(fn.body, node => {
+                if (!tested && ts.isIdentifier(node) && node.text === param.name.text && checker.getSymbolAtLocation(node) === paramSym && inCondition(ts, node))
+                    tested = node;
+            });
+            if (!tested)
+                return;
+            const anchor = h.touched(param) ? param : entry.prod.every(c => h.spanTouched(c)) ? entry.prod[0] : undefined;
+            if (!anchor)
+                return;
+            const fnName = ts.isFunctionDeclaration(fn) ? fn.name.text : fn.parent.name.text;
+            h.report('constant-argument', 'A parameter every production call passes the same value', anchor, `\`${fnName}\`'s \`${param.name.text}\` is ${texts[0]} in all ${entry.prod.length} production calls (e.g. ${h.at(entry.prod[0])}), yet ${h.at(tested)} branches on it: the other branch never runs outside tests.`, `Inline the value and delete the branch, or pass the real value where it is called.`);
+        });
+    }
+}

package/dist/review/typed/dead-null-guards.d.ts

@@ -0,0 +1,34 @@
+/**
+ * dead-null-guard: code that guards a column against null after the query already made it non-null.
+ *
+ * A query that filters `col` (`.not(col, 'is', null)`, or a range or equality on it, which SQL never
+ * matches on NULL) returns rows whose `col` is never null. A guard on `row.col` in code that reads
+ * those rows (`?? fallback`, `?.`, `== null`, `!row.col`) can then never fire: dead code that
+ * reviewers keep finding round after round, and a row type that keeps telling the next reader
+ * otherwise. nullable-filtered-column names the type; this names each guard.
+ *
+ * Reported only when it is certain: the row type is the one the filtered query returns (`.returns<Row[]>()`
+ * or `read…<Row>()`), EVERY query in the program that returns that row type filters the same column,
+ * and no object literal builds a row of that type with the column missing or null. A guard is
+ * reported on a line the change touched, or anywhere in a file whose filtered query the change touched.
+ */
+import type * as TS from 'typescript';
+import type { TypedProgram } from './program.js';
+type Chain = Array<{
+    call: TS.CallExpression;
+    name: string;
+}>;
+export interface GuardHelpers {
+    chainOf: (call: TS.CallExpression) => Chain;
+    outermost: (call: TS.CallExpression) => boolean;
+    rowTypeOf: (chain: Chain, outer: TS.Node) => TS.Type | undefined;
+    strArg: (call: TS.CallExpression, i: number) => string | undefined;
+    isNullLiteral: (n: TS.Node | undefined) => boolean;
+    isNullable: (t: TS.Type) => boolean;
+    touched: (node: TS.Node) => boolean;
+    at: (node: TS.Node) => string;
+    report: (id: string, title: string, node: TS.Node, details: string, hint: string) => void;
+    walk: (node: TS.Node, fn: (n: TS.Node) => void) => void;
+}
+export declare function deadNullGuards(typed: TypedProgram, changedSources: TS.SourceFile[], h: GuardHelpers): void;
+export {};

package/dist/review/typed/dead-null-guards.js

@@ -0,0 +1,147 @@
+/** Filters SQL never satisfies with NULL: the column of each, as the query names it. */
+const NON_NULL_FILTERS = new Set(['gt', 'gte', 'lt', 'lte', 'eq', 'in', 'like', 'ilike']);
+export function deadNullGuards(typed, changedSources, h) {
+    const { ts, checker } = typed;
+    const nonNullColumns = (chain) => {
+        const columns = new Set();
+        for (const c of chain) {
+            const col = h.strArg(c.call, 0);
+            if (!col)
+                continue;
+            if (c.name === 'not' && h.strArg(c.call, 1) === 'is' && h.isNullLiteral(c.call.arguments[2]))
+                columns.add(col);
+            else if (NON_NULL_FILTERS.has(c.name) && !h.isNullLiteral(c.call.arguments[1]))
+                columns.add(col);
+        }
+        return columns;
+    };
+    // Every query in the program, by the row type it returns: which columns each guarantees non-null.
+    const byRow = new Map();
+    /**
+     * The named row types a query returns: the type itself, or each named member of an intersection
+     * (`Row & Record<string, unknown>`). A generic's type parameter and a library type are never a row.
+     */
+    const rowSymbols = (t) => {
+        if (!t || t.flags & ts.TypeFlags.TypeParameter)
+            return [];
+        if (t.isIntersection())
+            return t.types.flatMap(rowSymbols);
+        const sym = t.aliasSymbol ?? t.symbol;
+        const decl = sym?.declarations?.[0];
+        return sym && decl && !decl.getSourceFile().isDeclarationFile ? [sym] : [];
+    };
+    for (const sf of typed.appSources) {
+        if (!/\.(from|returns)\b|read[A-Z]\w*</.test(sf.text))
+            continue;
+        h.walk(sf, node => {
+            if (!ts.isCallExpression(node) || !h.outermost(node))
+                return;
+            const chain = h.chainOf(node);
+            if (chain.length === 0 || !startsQuery(chain))
+                return;
+            const columns = nonNullColumns(chain);
+            const touched = chain.some(c => h.touched(c.call.expression.name));
+            for (const sym of rowSymbols(h.rowTypeOf(chain, node))) {
+                const list = byRow.get(sym) ?? [];
+                list.push({ columns, touched, file: sf.fileName, node: chain[0].call });
+                byRow.set(sym, list);
+            }
+        });
+    }
+    // A query starts at `.from(…)`/`.select(…)` (or a bare `from(…)`); `query.or(after)` only continues one already counted.
+    function startsQuery(chain) {
+        if (chain.some(c => /^(from|select|table|selectFrom)$/.test(c.name)))
+            return true;
+        const root = chain[0].call.expression.expression;
+        return ts.isCallExpression(root) && ts.isIdentifier(root.expression) && /^(from|select|table)$/.test(root.expression.text);
+    }
+    for (const [sym, queries] of byRow) {
+        if (!sym.declarations?.length)
+            continue;
+        const type = checker.getDeclaredTypeOfSymbol(sym);
+        for (const prop of checker.getPropertiesOfType(type)) {
+            const decl = prop.declarations?.[0];
+            if (!decl || !ts.isPropertySignature(decl) || !decl.type)
+                continue;
+            const nullable = h.isNullable(checker.getTypeFromTypeNode(decl.type)) || !!decl.questionToken;
+            if (!nullable || !queries.every(q => q.columns.has(prop.name)))
+                continue;
+            if (builtWithout(typed, sym, prop.name, h))
+                continue;
+            const queryFiles = new Set(queries.filter(q => q.touched).map(q => q.file));
+            for (const guard of guardsOn(typed, prop, h)) {
+                if (!h.touched(guard.node) && !queryFiles.has(guard.node.getSourceFile().fileName))
+                    continue;
+                h.report('dead-null-guard', 'Null guard on a column the query makes non-null', guard.node, `\`${guard.text}\` guards \`${prop.name}\`, but ${queries.length === 1 ? 'the only query' : `all ${queries.length} queries`} returning \`${sym.name}\` (${h.at(queries[0].node)}) filter \`${prop.name}\` non-null, so this branch never runs${guard.emptyString ? ' (it still catches an empty string; compare with \'\' if that case is real)' : ''}.`, `Delete the guard, and narrow \`${sym.name}.${prop.name}\` to its non-null type so the next reader sees the guarantee.`);
+            }
+        }
+    }
+}
+/** A null guard on the property: `x.p ?? d`, `x.p?.y`, `x.p == null` / `!== null` / `=== undefined`, `!x.p`, `if (x.p)`, `x.p ? a : b`. */
+function guardsOn(typed, prop, h) {
+    const { ts, checker } = typed;
+    const found = [];
+    const decl = prop.declarations?.[0];
+    const isProp = (access) => {
+        const s = checker.getSymbolAtLocation(access.name);
+        return !!s && (s === prop || s.declarations?.[0] === decl);
+    };
+    const isNullish = (n) => n.kind === ts.SyntaxKind.NullKeyword || (ts.isIdentifier(n) && n.text === 'undefined');
+    for (const sf of typed.appSources) {
+        if (!sf.text.includes(prop.name))
+            continue;
+        h.walk(sf, node => {
+            if (!ts.isPropertyAccessExpression(node) || node.name.text !== prop.name || !isProp(node))
+                return;
+            const p = node.parent;
+            let guard;
+            if (ts.isBinaryExpression(p) && p.left === node && p.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken)
+                guard = p;
+            else if (ts.isPropertyAccessExpression(p) && p.expression === node && p.questionDotToken)
+                guard = p;
+            else if (ts.isBinaryExpression(p) && [ts.SyntaxKind.EqualsEqualsToken, ts.SyntaxKind.EqualsEqualsEqualsToken, ts.SyntaxKind.ExclamationEqualsToken, ts.SyntaxKind.ExclamationEqualsEqualsToken].includes(p.operatorToken.kind) && (isNullish(p.left === node ? p.right : p.left)))
+                guard = p;
+            else if (ts.isPrefixUnaryExpression(p) && p.operator === ts.SyntaxKind.ExclamationToken)
+                guard = p;
+            else if ((ts.isIfStatement(p) && p.expression === node) || (ts.isConditionalExpression(p) && p.condition === node))
+                guard = node;
+            // A number or boolean column is falsy for 0 or false too: a truthiness test there carries meaning beyond null.
+            // A string one is falsy only for '' besides null; that is reported, with the '' case named.
+            let emptyString = false;
+            if (guard && (ts.isPrefixUnaryExpression(p) || guard === node)) {
+                const t = checker.getNonNullableType(checker.getTypeAtLocation(node));
+                if (t.flags & (ts.TypeFlags.NumberLike | ts.TypeFlags.BooleanLike | ts.TypeFlags.BigIntLike))
+                    guard = undefined;
+                else if (t.flags & ts.TypeFlags.StringLike)
+                    emptyString = true;
+            }
+            if (guard)
+                found.push({ node: guard, text: guard.getText().slice(0, 60), emptyString });
+        });
+    }
+    return found;
+}
+/** An object literal typed as the row that leaves the property out or sets it null: then a null row exists, and the guard is not dead. */
+function builtWithout(typed, sym, name, h) {
+    const { ts, checker } = typed;
+    let built = false;
+    for (const sf of typed.appSources) {
+        if (built || !sf.text.includes(sym.name))
+            continue;
+        h.walk(sf, node => {
+            if (built || !ts.isObjectLiteralExpression(node))
+                return;
+            const ctx = checker.getContextualType(node);
+            // The row type itself, or a type built from it (`Row & Extra`, `Row | Other`).
+            const parts = ctx ? [ctx, ...(ctx.isUnionOrIntersection() ? ctx.types : [])] : [];
+            if (!parts.some(t => (t.aliasSymbol ?? t.symbol) === sym))
+                return;
+            const member = node.properties.find(p => p.name && ts.isIdentifier(p.name) && p.name.text === name);
+            if (node.properties.some(p => ts.isSpreadAssignment(p)))
+                return;
+            if (!member || (ts.isPropertyAssignment(member) && member.initializer.kind === ts.SyntaxKind.NullKeyword))
+                built = true;
+        });
+    }
+    return built;
+}

package/dist/review/typed/redundancy.js

@@ -9,6 +9,8 @@
  *   write-only-property       a property the hosts set and nothing reads. When the value only
  *                             leaves through serialisation to a callee the program does not declare
  *                             (a wire payload), that is a hint for the reviewer, not a block.
+ * Plus dead-null-guard (dead-null-guards.ts): a null guard on a column every query returning the row filters;
+ * constant-member and constant-argument (constant-inputs.ts): an input production never varies.
  * Plus a note, not yet proven on merged pull requests so it never blocks:
  *   nullable-not-null-column  the row type of `.from('t')` says `| null` for a column the
  *                             migrations make NOT NULL (`schema_migrations`, schema-nullability.ts).
@@ -21,6 +23,8 @@ import { emitsDeclarations } from '../package-layout.js';
 import { isTestFile } from '../test-files.js';
 import { loadProgram } from './program.js';
 import { loadSchemaNullability, tableKey } from './schema-nullability.js';
+import { deadNullGuards } from './dead-null-guards.js';
+import { constantInputs } from './constant-inputs.js';
 export const TYPED_CHECKS = 'typed-checks-unavailable';
 /** The typed checks on a change: nothing when it touches no TypeScript or the project has no tsconfig. */
 export function typedChecks(cwd, changedLines, config) {
@@ -147,6 +151,7 @@ function redundancyFailures(typed, changedLines, config) {
             }
         });
     }
+    deadNullGuards(typed, changedSources, { chainOf, outermost, rowTypeOf, strArg, isNullLiteral, isNullable, touched, at, report, walk });
     const declaredTypes = [];
     for (const sf of changedSources) {
         walk(sf, node => {
@@ -214,6 +219,7 @@ function redundancyFailures(typed, changedLines, config) {
         const stem = rel(t.node.getSourceFile()).replace(/\.[cm]?ts$/, '');
         return typed.textFiles.find(s => (word(t.name).test(s.text) || s.text.includes(stem) || s.text.includes(stem.replace(/^src\/lib\//, '$lib/'))) && new RegExp(`\\.${prop}\\b|\\{[^}]*\\b${prop}\\b[^}]*\\}`).test(s.text));
     };
+    constantInputs(typed, changedSources, declaredTypes, { hostsOf, touched, spanTouched, at, rel, report, walk });
     // A value of the type that leaves the program's sight: placed in a string, or passed to a callee the program does not declare.
     const escapeMemo = new Map();
     const escapes = (t) => {

package/dist/review/typed/redundancy.test.js

@@ -119,6 +119,142 @@ export async function scan(since: string): Promise<Row[]> {
         expect(broken.typedError).toMatch(/\.generated\/tsconfig\.json.*install the dependencies/s);
     }, 60_000);
 });
+describe('a null guard on a column the query makes non-null', () => {
+    const SESSION = `import { from } from './db';
+export interface Session { id: string; ended_at: string | null; label: string | null }
+export async function endedSessions(): Promise<Session[]> {
+    return from('sessions').not('ended_at', 'is', null).returns<Session[]>();
+}
+`;
+    const CONSUMER = `import { endedSessions } from './sessions';
+export async function summary(): Promise<string[]> {
+    const rows = await endedSessions();
+    return rows.map(row => {
+        if (row.ended_at == null) return 'open';
+        const ended = row.ended_at ?? 'never';
+        if (!row.label) return ended;
+        return row.label;
+    });
+}
+`;
+    const guards = async () => (await review()).advisory.filter(f => f.id === 'dead-null-guard').map(f => [f.files?.[0], f.line]);
+    it('names each guard the filter made dead, and leaves a guard on a column no query filters alone', async () => {
+        write('src/sessions.ts', SESSION);
+        write('src/summary.ts', CONSUMER);
+        git('add', '-A');
+        git('commit', '-qm', 'sessions');
+        expect(await guards()).toEqual([['src/summary.ts', 5], ['src/summary.ts', 6]]);
+    });
+    it("names a truthiness test on a filtered string column with the empty-string case, and leaves a number's alone", async () => {
+        write('src/sessions.ts', `import { from } from './db';
+export interface Visit { id: string; page: string | null; seconds: number | null }
+export async function visits(): Promise<Visit[]> {
+    return from('visits').not('page', 'is', null).not('seconds', 'is', null).returns<Visit[]>();
+}
+export async function pages(): Promise<string[]> {
+    return (await visits()).filter(v => !!v.page && !v.seconds).map(v => v.page ?? '');
+}
+`);
+        git('add', '-A');
+        git('commit', '-qm', 'visits');
+        const result = (await review()).advisory.filter(f => f.id === 'dead-null-guard');
+        expect(result.map(f => f.line)).toEqual([7, 7]); // \`!v.page\` and \`v.page ?? ''\`, not \`!v.seconds\`
+        expect(result.some(f => /empty string/.test(f.details ?? ''))).toBe(true);
+    });
+    it('follows a query typed through a generic pager and an intersection, and ignores the pager\'s own type parameter', async () => {
+        write('src/pager.ts', `import { from, type Query } from './db';
+export async function readAll<Row>(page: () => Query<unknown>): Promise<Row[]> {
+    await page();
+    return from('audit').returns<Row[]>(); // the helper's own query, typed by its parameter: not a row type
+}
+`);
+        write('src/sessions.ts', `import { from } from './db';
+import { readAll } from './pager';
+export interface Session { id: string; ended_at: string | null }
+export async function endedSessions(): Promise<Session[]> {
+    return readAll<Session & Record<string, unknown>>(() => from('sessions').not('ended_at', 'is', null));
+}
+export async function summary(): Promise<string[]> {
+    return (await endedSessions()).map(row => row.ended_at ?? 'never');
+}
+`);
+        git('add', '-A');
+        git('commit', '-qm', 'pager');
+        expect(await guards()).toEqual([['src/sessions.ts', 8]]);
+    });
+    it('says nothing when another query returns the same rows unfiltered', async () => {
+        write('src/sessions.ts', `${SESSION}export async function allSessions(): Promise<Session[]> {
+    return from('sessions').returns<Session[]>();
+}
+`);
+        write('src/summary.ts', CONSUMER);
+        git('add', '-A');
+        git('commit', '-qm', 'sessions');
+        expect(await guards()).toEqual([]);
+    });
+    it('says nothing when code builds such a row with the column null', async () => {
+        write('src/sessions.ts', `${SESSION}export const draft: Session = { id: 'new', ended_at: null, label: null };
+`);
+        write('src/summary.ts', CONSUMER);
+        git('add', '-A');
+        git('commit', '-qm', 'sessions');
+        expect(await guards()).toEqual([]);
+    });
+});
+describe('an input production never varies', () => {
+    const found = async (id) => (await review()).advisory.filter(f => f.id === id).map(f => [f.files?.[0], f.line]);
+    const commit = () => { git('add', '-A'); git('commit', '-qm', 'change'); };
+    it('names a member every production object sets to the same value while code branches on it; tests do not count', async () => {
+        write('src/jobs.ts', `export interface Job { id: string; retries: number }
+export function next(job: Job): string { return job.retries > 0 ? 'retry' : 'run'; }
+export const nightly: Job = { id: 'nightly', retries: 0 };
+export const hourly: Job = { id: 'hourly', retries: 0 };
+`);
+        write('src/jobs.test.ts', `import { next } from './jobs';
+export const flaky = next({ id: 'flaky', retries: 3 });
+`);
+        commit();
+        expect(await found('constant-member')).toEqual([['src/jobs.ts', 1]]);
+    });
+    it('says nothing when production sets the member differently', async () => {
+        write('src/jobs.ts', `export interface Job { id: string; retries: number }
+export function next(job: Job): string { return job.retries > 0 ? 'retry' : 'run'; }
+export const nightly: Job = { id: 'nightly', retries: 0 };
+export const hourly: Job = { id: 'hourly', retries: 2 };
+`);
+        commit();
+        expect(await found('constant-member')).toEqual([]);
+    });
+    it('names a parameter every production call passes the same literal while the body branches on it', async () => {
+        write('src/format.ts', `export function label(text: string, upper: boolean): string { return upper ? text.toUpperCase() : text; }
+export const a = label('one', false);
+export const b = label('two', false);
+export function wrap(text: string, client: { send(t: string): string }): string { return client.send(text); }
+`);
+        write('src/send.ts', `import { wrap } from './format';
+const client = { send: (t: string) => t };
+export const x = wrap('a', client);
+export const y = wrap('b', client); // the same variable name is not the same literal
+`);
+        write('src/format.test.ts', `import { label } from './format';
+export const loud = label('three', true);
+`);
+        commit();
+        expect(await found('constant-argument')).toEqual([['src/format.ts', 1]]);
+    });
+    it('says nothing when production calls vary, or the function is passed around as a value', async () => {
+        write('src/format.ts', `export function label(text: string, upper: boolean): string { return upper ? text.toUpperCase() : text; }
+export const a = label('one', false);
+export const b = label('two', true);
+export function shout(text: string, loud: boolean): string { return loud ? text + '!' : text; }
+export const c = shout('x', false);
+export const d = shout('y', false);
+export const handlers = [shout];
+`);
+        commit();
+        expect(await found('constant-argument')).toEqual([]);
+    });
+});
 describe('a nullable row type for a NOT NULL column, from migrations in another repository', () => {
     const SUPABASE = `export class Query<T> {
     select(_columns: string): Query<T> { return this; }

package/dist/review/unused-exports.js

@@ -113,7 +113,7 @@ export function unusedExportFailures(cwd, diff, config) {
     const points = pointsAtCache(cwd);
     return candidates
         .filter(exp => ![...(users.get(exp.name) ?? [])].some(user => !isOwnFile(user, exp) && !isTestFile(user) && points(user, exp.file)))
-        .map(unused);
+        .map(exp => unused(exp, !settings.block));
 }
 /**
  * In a project that emits declarations, an exported type named elsewhere in its own file is part
@@ -178,9 +178,10 @@ function filesNaming(cwd, names, excluded) {
     }
     return found;
 }
-function unused(exp) {
+function unused(exp, advisory) {
     return {
         id: 'unused-export',
+        ...(advisory ? { advisory } : {}),
         title: `Unused export \`${exp.name}\``,
         details: `\`${exp.name}\` is exported but no other file uses it (a test is not a consumer). An export nothing imports is dead code that readers and agents treat as part of the module's contract.`,
         severity: 'medium',

package/dist/review-learning/acted-on.d.ts

@@ -9,17 +9,37 @@ export interface ReviewComment {
     commit: string;
     body: string;
     author: string;
+    source?: 'person' | 'bot';
+    prAuthor?: string;
+    /** Whether the lines it points at changed before the merge. */
+    actedOn?: boolean;
+}
+/** A review's body: where a reviewer makes the points that are not about one line. */
+export interface ReviewBody {
+    id: string;
+    prNumber: number;
+    /** The commit the review was written on. */
+    commit: string;
+    body: string;
+    author: string;
+    source?: 'person' | 'bot';
+    prAuthor?: string;
 }
 export interface MergedPr {
     number: number;
     mergeSha: string;
     mergedAt: string;
     comments: ReviewComment[];
+    reviews: ReviewBody[];
 }
 /** git in one repository; tests substitute their own. */
 export type Git = (args: string[]) => string;
 export declare function gitIn(cwd: string): Git;
-/** Acted-on comments of a merged PR; comments whose commit or file cannot be found are skipped. */
-export declare function actedOn(git: Git, pr: MergedPr): ReviewComment[];
+/** Every comment whose commit and file can be found, each marked whether its lines changed before the merge. */
+export declare function withActedOn(git: Git, pr: MergedPr): ReviewComment[];
+/** Files the PR changed after a review was written: acted on when there are any. Empty when the commit is unavailable. */
+export declare function changedSince(git: Git, from: string, to: string): string[];
+/** A changed range on the old side, with how many lines it removed and added (a pure insertion removes none). */
+export type Hunk = [start: number, end: number, removed: number, added: number];
 /** Old-side line ranges that changed between two commits in one file. */
-export declare function changedHunks(git: Git, from: string, to: string, file: string): Array<[number, number]>;
+export declare function changedHunks(git: Git, from: string, to: string, file: string): Hunk[];

package/dist/review-learning/acted-on.js

@@ -2,23 +2,34 @@
  * Which review comments a developer acted on: the lines a comment points at
  * changed between the commit it was written on and the merged result.
  *
- * Acted-on comments are review work the team valued, whoever wrote them (a
- * person, a review bot, Rigour). A comment nobody acted on is not evidence of
- * anything and never becomes a lesson.
+ * Acted-on comments are review work the team valued. The learner keeps the
+ * people's by default (a review bot's acted-on comments are mostly one-off fixes,
+ * and on a busy repository they outnumber the people's many times over). A
+ * comment nobody acted on is not evidence of anything and never becomes a lesson.
  */
 import { execFileSync } from 'child_process';
 export function gitIn(cwd) {
     return (args) => execFileSync('git', args, { cwd, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024, stdio: ['ignore', 'pipe', 'ignore'] });
 }
-/** Acted-on comments of a merged PR; comments whose commit or file cannot be found are skipped. */
-export function actedOn(git, pr) {
+/** Every comment whose commit and file can be found, each marked whether its lines changed before the merge. */
+export function withActedOn(git, pr) {
     ensureCommits(git, pr);
-    return pr.comments.filter(comment => {
+    return pr.comments.flatMap(comment => {
         if (!hasFile(git, comment.commit, comment.path) || !hasFile(git, pr.mergeSha, comment.path))
-            return false;
-        return changedHunks(git, comment.commit, pr.mergeSha, comment.path).some(([s, e]) => s <= comment.end && comment.start <= e);
+            return [];
+        const acted = changedHunks(git, comment.commit, pr.mergeSha, comment.path).some(([s, e]) => s <= comment.end && comment.start <= e);
+        return [{ ...comment, actedOn: acted }];
     });
 }
+/** Files the PR changed after a review was written: acted on when there are any. Empty when the commit is unavailable. */
+export function changedSince(git, from, to) {
+    try {
+        return git(['diff', '--name-only', from, to]).split('\n').filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
 /** Old-side line ranges that changed between two commits in one file. */
 export function changedHunks(git, from, to, file) {
     let diff = '';
@@ -29,17 +40,18 @@ export function changedHunks(git, from, to, file) {
         return [];
     }
     const hunks = [];
-    for (const match of diff.matchAll(/^@@ -(\d+)(?:,(\d+))? \+\d+(?:,\d+)? @@/gm)) {
+    for (const match of diff.matchAll(/^@@ -(\d+)(?:,(\d+))? \+\d+(?:,(\d+))? @@/gm)) {
         const start = Number(match[1]);
-        const count = match[2] === undefined ? 1 : Number(match[2]);
-        // A pure insertion (count 0) sits after `start`; it touches that line.
-        hunks.push([start, start + Math.max(count, 1) - 1]);
+        const removed = match[2] === undefined ? 1 : Number(match[2]);
+        const added = match[3] === undefined ? 1 : Number(match[3]);
+        // A pure insertion (removed 0) sits after `start`; it touches that line.
+        hunks.push([start, start + Math.max(removed, 1) - 1, removed, added]);
     }
     return hunks;
 }
 /** Commits a comment was written on may have been force-pushed away; GitHub still serves the PR ref. */
 function ensureCommits(git, pr) {
-    const missing = [...new Set(pr.comments.map(c => c.commit))].filter(sha => !hasCommit(git, sha));
+    const missing = [...new Set([...pr.comments.map(c => c.commit), ...pr.reviews.map(r => r.commit)])].filter(sha => !hasCommit(git, sha));
     if (missing.length === 0)
         return;
     try {