@scientific-method/standard-checker 2.0.0 → 2.2.0

package/README.md

@@ -20,7 +20,9 @@ A pass ends with `spec check passed:` and the counts of entries, parity rows and
 step of the check did not run, it ends with `spec check passed with skipped steps:`, the counts, and
 `Skipped:` followed by each step and why, such as
 `Skipped: Kaitai compilation of 2 definitions (--no-ksy).` A failing run lists the skipped steps
-after its problems.
+after its problems. A `call` or `emit` whose arguments cannot be counted, because the Parameters
+section it is counted against is missing or is not `None.` or a list of parameters, or because its
+argument list is never closed, is a skipped step as well.
 
 Without `--base`, the checker compares the spec with where HEAD forked from `origin/$GITHUB_BASE_REF`,
 or from `origin/main` when that variable is unset. Outside a git repository, in a shallow clone, or

package/dist/checks/arguments.d.ts

@@ -0,0 +1,17 @@
+import type { Context } from "../context.ts";
+/**
+ * The number of parameters a rule's Parameters section lists: 0 for `None.`, otherwise the number
+ * of items of a Markdown list whose items each open with a code span holding a name, or a name, a
+ * colon and a type, followed directly by a colon (`` - `gang: FMT-DATA-005`: the gang ``). An item
+ * may continue on indented lines. Null when the section holds anything else, so its parameters
+ * cannot be counted: `None known.`, prose after the list, or an item that names two parameters
+ * (`` - `x`, `y`: the cell ``) or puts anything between its code span and the colon.
+ */
+export declare function parameterCount(section: string): number | null;
+/**
+ * The number of arguments in the parenthesised list that opens at code[open], counting the commas
+ * outside nested brackets. Null when the list is not closed.
+ */
+export declare function argumentCount(code: string, open: number): number | null;
+/** Checks the argument count of every call, function call and emit in a live rule's procedure. */
+export declare function checkArgumentCounts(ctx: Context): void;

package/dist/checks/arguments.js

@@ -0,0 +1,195 @@
+// Argument counts: every `call` passes one argument for each item of the called rule's Parameters
+// list, every call to a function a rule defines one for each parameter of its `define`, and every
+// `emit` one for each item of the Parameters list of each handler its glossary entry names. Two
+// `emit`s of one event in rules that share a build pass the same number of arguments, which is the
+// only check an event with no handlers gets.
+//
+// A call to a split rule, and an emit to a split handler, is counted against each entry of the
+// split that lists one of the calling or emitting rule's builds, and a call to a function that a
+// split rule defines against the `define` of each such entry. A Parameters section in any other
+// form than `None.` or the list gives no count, so the calls and emits that depend on it are named
+// as a skipped step and do not fail the check. A call or emit whose argument list is never closed
+// is named as a skipped step too. Only live rules are checked, and only live rules' `define`s are
+// counted against.
+import { asList, idsIn, kindOf } from "../ids.js";
+import { BUILTINS, defines, procedureLocals, withoutCommentsAndStrings } from "./rules.js";
+/**
+ * The number of parameters a rule's Parameters section lists: 0 for `None.`, otherwise the number
+ * of items of a Markdown list whose items each open with a code span holding a name, or a name, a
+ * colon and a type, followed directly by a colon (`` - `gang: FMT-DATA-005`: the gang ``). An item
+ * may continue on indented lines. Null when the section holds anything else, so its parameters
+ * cannot be counted: `None known.`, prose after the list, or an item that names two parameters
+ * (`` - `x`, `y`: the cell ``) or puts anything between its code span and the colon.
+ */
+export function parameterCount(section) {
+    const text = section.trim();
+    if (text === "None.")
+        return 0;
+    let count = 0;
+    for (const line of text.split("\n")) {
+        if (line.trim() === "")
+            continue;
+        if (/^[-*+]\s/.test(line)) {
+            if (!/^[-*+]\s+`[a-z_][a-z0-9_]*(?:\s*:\s*[^`\s][^`]*)?`:/.test(line))
+                return null;
+            count++;
+        }
+        else if (!(count > 0 && /^\s/.test(line)))
+            return null;
+    }
+    return count > 0 ? count : null;
+}
+/**
+ * The number of arguments in the parenthesised list that opens at code[open], counting the commas
+ * outside nested brackets. Null when the list is not closed.
+ */
+export function argumentCount(code, open) {
+    let depth = 0;
+    let commas = 0;
+    let empty = true;
+    for (let i = open + 1; i < code.length; i++) {
+        const c = code[i];
+        if (c === "(" || c === "[" || c === "{")
+            depth++;
+        else if (c === ")" || c === "]" || c === "}") {
+            if (depth === 0)
+                return empty ? 0 : commas + 1;
+            depth--;
+        }
+        else if (c === "," && depth === 0)
+            commas++;
+        if (!/\s/.test(c))
+            empty = false;
+    }
+    return null;
+}
+// The argument count of a call or emit whose name ends at end: 0 when no list follows the name.
+const countAfter = (code, end) => {
+    const opening = /[ \t]*\(/y;
+    opening.lastIndex = end;
+    return opening.test(code) ? argumentCount(code, opening.lastIndex - 1) : 0;
+};
+const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+/** Checks the argument count of every call, function call and emit in a live rule's procedure. */
+export function checkArgumentCounts(ctx) {
+    const { problem, skip } = ctx;
+    const { entries, glossary } = ctx.spec;
+    const live = [...entries].filter(([, e]) => e.kind === "RULE" && e.meta.status !== "superseded");
+    const builds = (e) => asList(e.meta.builds);
+    const sharesBuild = (a, b) => builds(a).some((x) => builds(b).includes(x));
+    const parametersOf = (id) => entries.get(id).sections.find((s) => s.title === "Parameters")?.text;
+    const counts = new Map();
+    const countOf = (id) => {
+        if (!counts.has(id))
+            counts.set(id, parameterCount(parametersOf(id) ?? ""));
+        return counts.get(id);
+    };
+    // The entries whose Parameters section a call to rule from caller is counted against: each entry
+    // of rule's split that lists one of the caller's builds, or rule itself when none does.
+    const targetsOf = (rule, caller) => {
+        const group = [rule, ...asList(entries.get(rule).meta.split_with)].filter((x) => entries.get(x)?.kind === "RULE");
+        const sharing = [...new Set(group)].filter((x) => sharesBuild(entries.get(x), caller));
+        return sharing.length ? sharing : [rule];
+    };
+    // Rule ID -> what could not be counted against its Parameters section -> how many times.
+    const uncounted = new Map();
+    const cannotCount = (target, what) => {
+        if (!uncounted.has(target))
+            uncounted.set(target, new Map());
+        const m = uncounted.get(target);
+        m.set(what, (m.get(what) ?? 0) + 1);
+    };
+    // What could not be counted because its argument list is never closed.
+    const unclosed = [];
+    // Function name -> the rules that define it, with the parameter count of each define.
+    const defined = new Map();
+    for (const [id, e] of live)
+        for (const { name, params } of defines(withoutCommentsAndStrings(e.code ?? ""))) {
+            if (!defined.has(name))
+                defined.set(name, []);
+            defined.get(name).push({ id, count: params.length });
+        }
+    // Event name -> the argument counts its emits pass, with the rule each comes from.
+    const emitted = new Map();
+    for (const [id, e] of live) {
+        const { file } = e;
+        const code = withoutCommentsAndStrings(e.code ?? "");
+        for (const m of code.matchAll(/\bcall\s+(RULE-[A-Z0-9]+-\d+)/g)) {
+            const called = entries.get(m[1]);
+            if (!called || called.kind !== "RULE")
+                continue;
+            const n = countAfter(code, m.index + m[0].length);
+            if (n === null) {
+                unclosed.push(`call of ${m[1]} in ${id}`);
+                continue;
+            }
+            for (const target of targetsOf(m[1], e)) {
+                const want = countOf(target);
+                if (want === null)
+                    cannotCount(target, `call in ${id}`);
+                else if (want !== n)
+                    problem(file, target === m[1]
+                        ? `calls ${m[1]} with ${plural(n, "argument")}, but its Parameters section lists ${plural(want, "parameter")}`
+                        : `calls ${m[1]} with ${plural(n, "argument")}, but the Parameters section of ${target}, the entry of the split that lists a build of this rule, lists ${plural(want, "parameter")}`);
+            }
+        }
+        // A name the procedure declares itself, or a built-in, is not a function another rule defines.
+        const locals = procedureLocals(code, parametersOf(id) ?? "");
+        for (const m of code.matchAll(/(?<![.\w])(?<!\b(?:define|emit)\s+)([a-z_][a-z0-9_]*)\s*\(/g)) {
+            const owners = defined.get(m[1]);
+            if (!owners || locals.has(m[1]) || BUILTINS.has(m[1]))
+                continue;
+            const n = argumentCount(code, m.index + m[0].length - 1);
+            if (n === null) {
+                unclosed.push(`call of ${m[1]}() in ${id}`);
+                continue;
+            }
+            const near = owners.filter((o) => o.id === id || sharesBuild(entries.get(o.id), e));
+            if (near.length) {
+                for (const { id: owner, count } of near)
+                    if (count !== n)
+                        problem(file, `calls ${m[1]}() with ${plural(n, "argument")}, but its define in ${owner} takes ${plural(count, "parameter")}`);
+            }
+            else if (owners.every((o) => o.count !== n))
+                // No define lists one of this rule's builds, so the call is wrong only if it fits none of them.
+                problem(file, owners.length === 1
+                    ? `calls ${m[1]}() with ${plural(n, "argument")}, but its define in ${owners[0].id} takes ${plural(owners[0].count, "parameter")}`
+                    : `calls ${m[1]}() with ${plural(n, "argument")}, but none of its defines takes that many (${owners.map((o) => `${plural(o.count, "parameter")} in ${o.id}`).join(", ")})`);
+        }
+        for (const m of code.matchAll(/\bemit\s+([A-Za-z_][A-Za-z0-9_]*)/g)) {
+            const event = m[1];
+            const n = countAfter(code, m.index + m[0].length);
+            if (n === null) {
+                unclosed.push(`emit of ${event} in ${id}`);
+                continue;
+            }
+            if (!emitted.has(event))
+                emitted.set(event, []);
+            const others = emitted.get(event);
+            const other = others.find((o) => o.count !== n && (o.id === id || sharesBuild(o.entry, e)));
+            if (other)
+                problem(file, other.id === id
+                    ? `emits ${event} with ${plural(n, "argument")}, but also emits it with ${plural(other.count, "argument")}`
+                    : `emits ${event} with ${plural(n, "argument")}, but ${other.id} emits it with ${plural(other.count, "argument")}`);
+            if (!others.some((o) => o.id === id && o.count === n))
+                others.push({ id, entry: e, count: n });
+            const handlers = idsIn(glossary.get(event)).filter((x) => kindOf(x) === "RULE" && entries.get(x)?.kind === "RULE");
+            for (const handler of new Set(handlers.flatMap((h) => targetsOf(h, e)))) {
+                const want = countOf(handler);
+                if (want === null)
+                    cannotCount(handler, `emit of ${event} in ${id}`);
+                else if (want !== n)
+                    problem(file, `emits ${event} with ${plural(n, "argument")}, but the Parameters section of its handler ${handler} lists ${plural(want, "parameter")}`);
+            }
+        }
+    }
+    for (const [target, whats] of uncounted) {
+        const list = [...whats].map(([what, times]) => (times > 1 ? `${what} (${times} times)` : what)).join(", ");
+        const why = parametersOf(target) === undefined
+            ? "which has no Parameters section"
+            : "whose Parameters section is not None. or a list of parameters";
+        skip(`argument counts against ${target}, ${why} (${list})`);
+    }
+    for (const what of new Set(unclosed))
+        skip(`the argument count of the ${what}, whose argument list is not closed`);
+}

package/dist/checks/deviations.d.ts

@@ -3,8 +3,14 @@ import type { Context } from "../context.ts";
 export interface Deviation {
     /** The spec IDs its Departs from item names. */
     departs: string[];
+    /** The spec IDs its Replaces item names: the entries it replaces entirely. */
+    replaces: string[];
     /** Whether its Dropped item says it was dropped. */
     dropped: boolean;
+    /** Whether its Default is mandatory. */
+    mandatory: boolean;
+    /** The test files its Tests item lists, which check the rebuild does what the deviation says. */
+    tests: string[];
     /** Its file. */
     file: string;
 }

package/dist/checks/deviations.js

@@ -3,7 +3,7 @@
 import { existsSync, statSync } from "node:fs";
 import { basename, join } from "node:path";
 import { checkResolves, isSuperseded } from "../evidence.js";
-import { termFiles } from "../files.js";
+import { checkTestFiles, termFiles } from "../files.js";
 import { areaOf, idsIn, kindOf } from "../ids.js";
 import { readText } from "../markdown.js";
 /** Reads and checks deviations/. Returns deviation ID -> the deviation. */
@@ -44,10 +44,12 @@ export function checkDeviations(ctx) {
                 const item = Object.fromEntries(items);
                 const order = [
                     "Departs from",
+                    ...("Replaces" in item ? ["Replaces"] : []),
                     "Reason",
                     "Setting",
                     "Default",
                     ...("Justification" in item ? ["Justification"] : []),
+                    ...("Tests" in item ? ["Tests"] : []),
                     "Dropped",
                 ];
                 if (items
@@ -59,7 +61,12 @@ export function checkDeviations(ctx) {
                 const dropped = Boolean(item.Dropped) && item.Dropped !== "no";
                 if (dropped && !/^\d{4}-\d{2}-\d{2}\b/.test(item.Dropped))
                     problem(file, `${title}: Dropped gives the date, YYYY-MM-DD, and the reason`);
+                const replaces = idsIn(item.Replaces);
                 checkResolves(ctx, file, departs, `${title} Departs from`);
+                checkResolves(ctx, file, replaces, `${title} Replaces`);
+                // The Tests item lists the test files that check the rebuild does what the deviation says. A
+                // dropped deviation's tests may have gone with it.
+                let tests = [];
                 if (!dropped) {
                     if (!departs.some((x) => ["RULE", "FMT", "SCR"].includes(kindOf(x))))
                         problem(file, `${title}: Departs from names at least one rule, format or screen`);
@@ -67,8 +74,28 @@ export function checkDeviations(ctx) {
                         if (isSuperseded(entries, x))
                             problem(file, `${title} departs from ${x}, which is superseded`);
                     checkDeviationDefault(ctx, file, title, item, departs);
+                    // Replaces names the entries of Departs from that a mandatory deviation replaces entirely, which
+                    // is what lets their rows become deviated.
+                    if ("Replaces" in item) {
+                        if (item.Default !== "mandatory")
+                            problem(file, `${title}: only a mandatory deviation has a Replaces item`);
+                        if (replaces.length === 0)
+                            problem(file, `${title}: Replaces names at least one entry`);
+                        for (const x of replaces) {
+                            if (!departs.includes(x))
+                                problem(file, `${title}: Replaces names ${x}, which Departs from does not`);
+                            if (!["RULE", "FMT", "SCR"].includes(kindOf(x)))
+                                problem(file, `${title}: Replaces names ${x}, which is not a rule, format or screen`);
+                        }
+                    }
+                    // Nothing records a local run of a deviation's tests, so they run in CI and never need GAME_DIR.
+                    if ("Tests" in item) {
+                        tests = checkTestFiles(ctx, file, title, item.Tests, false);
+                        if (tests.length === 0)
+                            problem(file, `${title}: Tests lists at least one test file; leave the item out when there is none`);
+                    }
                 }
-                deviations.set(title, { departs, dropped, file });
+                deviations.set(title, { departs, replaces, dropped, mandatory: item.Default === "mandatory", tests, file });
             }
     }
     return deviations;

package/dist/checks/fields.js

@@ -21,7 +21,7 @@
 // unchecked. A declaration that writes no type, such as a parameter the Parameters section describes
 // in prose or an untyped parameter of a define, gives none and so differs from no other.
 import { asList } from "../ids.js";
-import { parameterNames, withoutCommentsAndStrings } from "./rules.js";
+import { defines, parameterNames, withoutCommentsAndStrings } from "./rules.js";
 const sameType = (a, b) => !!a && !!b && a.format.join(" ") === b.format.join(" ") && a.pointer === b.pointer && a.list === b.list;
 const FMT_ID = String.raw `FMT-[A-Z][A-Z0-9]*-\d{3,}`;
 // A type in the notation that holds a structure: a format ID, a pointer to one, or a list of either.
@@ -184,9 +184,8 @@ export function checkFieldNames(ctx, { layouts }) {
         for (const name of parameterNames(params))
             declare(name, fixed(typedParams.has(name) ? typedParams.get(name) : undefined, "the Parameters section"));
         for (const line of lines) {
-            const d = /\bdefine\s+[a-z_][a-z0-9_]*\s*\(([^)]*)\)/.exec(line);
-            if (d)
-                for (const p of d[1].split(",")) {
+            for (const d of defines(line))
+                for (const p of d.params) {
                     const [name, type] = p.split(":");
                     if (/^[a-z_][a-z0-9_]*$/.test(name.trim()))
                         declare(name.trim(), fixed(type === undefined ? undefined : typeOf(type), "its define"));

package/dist/checks/parity.js

@@ -4,7 +4,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { basename, join } from "node:path";
 import { collectPlaceholders } from "../code-files.js";
 import { mayBeInterrupted, onlyEmulatedRuns } from "../evidence.js";
-import { markdownTree, walk } from "../files.js";
+import { checkTestFiles, markdownTree, NEEDS_GAME, walk } from "../files.js";
 import { areaOf, compareIds, kindOf } from "../ids.js";
 import { readText, tables } from "../markdown.js";
 import { LINE_LIMIT } from "../standard.js";
@@ -24,10 +24,9 @@ export function checkParity(ctx, deviations) {
     const parityRows = new Map(); // spec ID -> { cells, file }
     const parityCounts = { status: {}, code: {} };
     const validatedTests = new Map(); // marked test file of a validated row -> [{ specId, file }]
-    // A test file that reads the original's files through GAME_DIR says so with this comment. It runs
+    // A test file that reads the original's files through GAME_DIR says so with NEEDS_GAME. It runs
     // only on a maintainer's machine, so its validated rows need it in VALIDATION.md; every other test
     // runs in CI.
-    const NEEDS_GAME = /needs:\s*GAME_DIR/;
     const needsGame = (p) => existsSync(p) && NEEDS_GAME.test(readFileSync(p, "utf8"));
     // A PARITY.md that still holds the rows is left alone until they have moved, so the check does not
     // overwrite them with the totals.
@@ -101,24 +100,7 @@ export function checkParity(ctx, deviations) {
                     problem(file, `${specId}: an unknown entry cannot be complete`);
                 if (code === "complete" && placeholders.has(specId))
                     problem(file, `${specId}: a PLACEHOLDER comment cites it, so it cannot be complete`);
-                const testFiles = tests === "None"
-                    ? []
-                    : tests
-                        .split(",")
-                        .map((x) => x.trim())
-                        .filter(Boolean);
-                for (const tf of testFiles) {
-                    const p = join(repoDir, tf);
-                    if (!existsSync(p))
-                        problem(file, `${specId}: test file ${tf} does not exist`);
-                    else {
-                        const text = readFileSync(p, "utf8");
-                        if (!text.includes(specId))
-                            problem(file, `${specId}: test file ${tf} does not mention ${specId}`);
-                        if (text.includes("GAME_DIR") && !NEEDS_GAME.test(text))
-                            problem(file, `${specId}: test file ${tf} mentions GAME_DIR without a "needs: GAME_DIR" comment, so CI would skip it unseen`);
-                    }
-                }
+                const testFiles = checkTestFiles(ctx, file, specId, tests);
                 const listedDevs = devs === "None"
                     ? []
                     : devs
@@ -131,11 +113,25 @@ export function checkParity(ctx, deviations) {
                     .sort(compareIds);
                 if (listedDevs.slice().sort(compareIds).join(",") !== expectedDevs.join(","))
                     problem(file, `${specId}: Deviations must be ${expectedDevs.join(", ") || "None"}`);
+                // A row whose entry a mandatory deviation replaces entirely cannot be compared with the original,
+                // so it has no tests of its own: they belong in the deviation's Tests item. It is deviated once
+                // every mandatory deviation it lists has tests.
+                const mandatory = listedDevs
+                    .map((x) => deviations.get(x))
+                    .filter((d) => Boolean(d?.mandatory && !d.dropped));
+                const replacing = listedDevs.find((x) => {
+                    const d = deviations.get(x);
+                    return d?.mandatory && !d.dropped && d.replaces.includes(specId);
+                });
+                const replaced = replacing !== undefined;
+                if (replaced && testFiles.length > 0)
+                    problem(file, `${specId}: ${replacing} replaces it, so Tests must be None; list the tests in the deviation's Tests item`);
+                const deviated = replaced && mandatory.every((d) => d.tests.length > 0);
                 let expectedStatus;
                 if (code !== "complete" || e.meta.status === "disputed")
                     expectedStatus = e.meta.status;
-                else if (testFiles.length === 0)
-                    expectedStatus = "implemented";
+                else if (testFiles.length === 0 || replaced)
+                    expectedStatus = deviated ? "deviated" : "implemented";
                 else if (["supported", "established"].includes(e.meta.status))
                     expectedStatus = "validated";
                 else {

package/dist/checks/rules.d.ts

@@ -7,5 +7,21 @@ import type { FormatNames } from "./formats.ts";
 export declare const withoutCommentsAndStrings: (code: string) => string;
 /** The names a rule's Parameters section declares: each lower-case name that opens a code span, as `n` or `n: type`. */
 export declare const parameterNames: (params: string) => string[];
+/**
+ * Each `define` in a procedure: the function's name and its parameters as written, with their types
+ * (`n: UINT16`). A define with no parameters has an empty list.
+ */
+export declare const defines: (code: string) => {
+    name: string;
+    params: string[];
+}[];
+/**
+ * The names a procedure declares for itself: its `let`s, its loop variables, the parameters of its
+ * `define`s and the names its rule's Parameters section lists. A call to one of these names calls
+ * the local value, not a function another rule defines.
+ */
+export declare function procedureLocals(code: string, params: string): Set<string>;
+/** The functions every procedure may call without a rule defining them. */
+export declare const BUILTINS: Set<string>;
 /** Checks every rule's procedure. Sets Entry.code on every rule entry, superseded ones included. */
 export declare function checkRules(ctx: Context, { enumNames }: FormatNames): void;

package/dist/checks/rules.js

@@ -13,7 +13,37 @@ import { KINDS, LIST_LIMIT } from "../standard.js";
 export const withoutCommentsAndStrings = (code) => code.replace(/"[^"\n]*"/g, '""').replace(/#.*$/gm, "");
 /** The names a rule's Parameters section declares: each lower-case name that opens a code span, as `n` or `n: type`. */
 export const parameterNames = (params) => [...params.matchAll(/`([a-z_][a-z0-9_]*)(?=`|\s*:)/g)].map((m) => m[1]);
-const BUILTINS = new Set([
+/**
+ * Each `define` in a procedure: the function's name and its parameters as written, with their types
+ * (`n: UINT16`). A define with no parameters has an empty list.
+ */
+export const defines = (code) => [...code.matchAll(/\bdefine\s+([a-z_][a-z0-9_]*)\s*\(([^)]*)\)/g)].map((m) => ({
+    name: m[1],
+    params: m[2]
+        .split(",")
+        .map((p) => p.trim())
+        .filter((p) => p !== ""),
+}));
+/**
+ * The names a procedure declares for itself: its `let`s, its loop variables, the parameters of its
+ * `define`s and the names its rule's Parameters section lists. A call to one of these names calls
+ * the local value, not a function another rule defines.
+ */
+export function procedureLocals(code, params) {
+    const locals = new Set();
+    for (const m of code.matchAll(/\blet\s+([a-z_][a-z0-9_]*)/g))
+        locals.add(m[1]);
+    for (const m of code.matchAll(/\bfor\s+(?:each\s+)?([a-z_][a-z0-9_]*)\s+in\b/g))
+        locals.add(m[1]);
+    for (const d of defines(code))
+        for (const p of d.params)
+            locals.add(p.split(":")[0].trim());
+    for (const name of parameterNames(params))
+        locals.add(name);
+    return locals;
+}
+/** The functions every procedure may call without a rule defining them. */
+export const BUILTINS = new Set([
     "min",
     "max",
     "abs",
@@ -191,17 +221,7 @@ export function checkRules(ctx, { enumNames }) {
         if (/\b0x[0-9A-Fa-f]{6,}\b/.test(noNeutral) && /\b0x00[4-9A-F][0-9A-F]{5}\b/.test(noNeutral))
             problem(file, "the procedure contains what looks like an address outside a neutral name");
         // Functions called without `call`
-        const locals = new Set();
-        for (const m of code.matchAll(/\blet\s+([a-z_][a-z0-9_]*)/g))
-            locals.add(m[1]);
-        for (const m of code.matchAll(/\bfor\s+(?:each\s+)?([a-z_][a-z0-9_]*)\s+in\b/g))
-            locals.add(m[1]);
-        for (const m of code.matchAll(/\bdefine\s+[a-z_][a-z0-9_]*\s*\(([^)]*)\)/g))
-            for (const p of m[1].split(","))
-                locals.add(p.split(":")[0].trim());
-        const params = e.sections.find((s) => s.title === "Parameters")?.text ?? "";
-        for (const name of parameterNames(params))
-            locals.add(name);
+        const locals = procedureLocals(code, e.sections.find((s) => s.title === "Parameters")?.text ?? "");
         for (const m of code.matchAll(/(?<![.\w])([a-z_][a-z0-9_]*)\s*\(/g)) {
             const name = m[1];
             if (BUILTINS.has(name) || KEYWORDS.has(name) || locals.has(name))

package/dist/files.d.ts

@@ -1,3 +1,4 @@
+import type { Context } from "./context.ts";
 /** A path with backslashes turned into forward slashes. */
 export declare const toSlash: (p: string) => string;
 /**
@@ -9,3 +10,12 @@ export declare function walk(dir: string, fn: (path: string) => void): void;
 export declare function markdownTree(dir: string): Map<string, string>;
 /** The paths of the files and directories in dir, apart from .gitkeep. */
 export declare const termFiles: (dir: string) => string[];
+/** The comment of a test file that reads the original's files through GAME_DIR, which CI skips. */
+export declare const NEEDS_GAME: RegExp;
+/**
+ * Checks the test files that cell lists for id, comma-separated by their path from the repository
+ * root, and returns them. `None` lists none. Each listed path is a file that mentions id, and one that
+ * mentions GAME_DIR carries a "needs: GAME_DIR" comment, since CI skips it. Without needsGame, a file
+ * that mentions GAME_DIR at all is a problem. Each problem goes to file.
+ */
+export declare function checkTestFiles(ctx: Context, file: string, id: string, cell: string, needsGame?: boolean): string[];

package/dist/files.js

@@ -1,5 +1,5 @@
-// Walking the repository's directories.
-import { existsSync, readdirSync, statSync } from "node:fs";
+// Walking the repository's directories, and reading the test files a row or deviation lists.
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { join, relative } from "node:path";
 /** A path with backslashes turned into forward slashes. */
 export const toSlash = (p) => p.replaceAll("\\", "/");
@@ -33,3 +33,39 @@ export function markdownTree(dir) {
 export const termFiles = (dir) => readdirSync(dir)
     .filter((name) => name !== ".gitkeep")
     .map((name) => join(dir, name));
+/** The comment of a test file that reads the original's files through GAME_DIR, which CI skips. */
+export const NEEDS_GAME = /needs:\s*GAME_DIR/;
+/**
+ * Checks the test files that cell lists for id, comma-separated by their path from the repository
+ * root, and returns them. `None` lists none. Each listed path is a file that mentions id, and one that
+ * mentions GAME_DIR carries a "needs: GAME_DIR" comment, since CI skips it. Without needsGame, a file
+ * that mentions GAME_DIR at all is a problem. Each problem goes to file.
+ */
+export function checkTestFiles(ctx, file, id, cell, needsGame = true) {
+    const { problem } = ctx;
+    const listed = cell === "None"
+        ? []
+        : cell
+            .split(",")
+            .map((x) => x.replaceAll("`", "").trim())
+            .filter(Boolean);
+    // Whole IDs only, as ID_RE reads them, so RULE-SCORE-0010 does not mention RULE-SCORE-001.
+    const mention = new RegExp(`\\b${id}\\b`);
+    for (const tf of listed) {
+        const p = join(ctx.config.repoDir, tf);
+        if (!existsSync(p))
+            problem(file, `${id}: test file ${tf} does not exist`);
+        else if (!statSync(p).isFile())
+            problem(file, `${id}: test file ${tf} is not a file`);
+        else {
+            const text = readFileSync(p, "utf8");
+            if (!mention.test(text))
+                problem(file, `${id}: test file ${tf} does not mention ${id}`);
+            if (text.includes("GAME_DIR") && !needsGame)
+                problem(file, `${id}: test file ${tf} mentions GAME_DIR, but it has to run in CI`);
+            else if (text.includes("GAME_DIR") && !NEEDS_GAME.test(text))
+                problem(file, `${id}: test file ${tf} mentions GAME_DIR without a "needs: GAME_DIR" comment, so CI would skip it unseen`);
+        }
+    }
+    return listed;
+}

package/dist/generate/parity-md.js

@@ -21,7 +21,7 @@ export function generateParity(ctx, parity, generated) {
         "",
         "| Status | Rows |",
         "|---|---|",
-        ...["unknown", "sourced", "supported", "established", "disputed", "implemented", "validated"].map((k) => `| ${k} | ${parityCounts.status[k] ?? 0} |`),
+        ...["unknown", "sourced", "supported", "established", "disputed", "implemented", "deviated", "validated"].map((k) => `| ${k} | ${parityCounts.status[k] ?? 0} |`),
         "",
         "| Code | Rows |",
         "|---|---|",

package/dist/standard-checker.js

@@ -62,6 +62,7 @@
 import { readFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { checkArgumentCounts } from "./checks/arguments.js";
 import { checkBase } from "./checks/base.js";
 import { checkCommentAddresses } from "./checks/comment-addresses.js";
 import { checkAcrossEntries } from "./checks/cross-entry.js";
@@ -98,6 +99,7 @@ const spec = loadSpec({ config, problem });
 const ctx = { config, problem, skip, spec, codeFiles: createCodeFiles(config, dirname(selfPath)) };
 const formatNames = checkEntries(ctx);
 checkRules(ctx, formatNames);
+checkArgumentCounts(ctx);
 checkFieldNames(ctx, formatNames);
 checkAcrossEntries(ctx, formatNames);
 compileKaitai(ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scientific-method/standard-checker",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "Checks a restoration's spec/, parity/ and deviations/ against version 1 of the dinorefurb documentation standard.",
   "type": "module",
   "license": "MIT",