@amritk/nish 0.12.0 → 0.14.0

package/scripts/ci-profile.mjs

@@ -33,20 +33,21 @@
  * runner measured about 1.34x this box on the same suite, so the shape
  * transfers and the absolute seconds do not.
  */
-import { spawn } from "node:child_process";
+import { spawn } from "node:child_process"
 
-const argv = process.argv.slice(2);
-const asJson = argv.includes("--json");
-const topAt = argv.indexOf("--top");
-const TOP = topAt >= 0 && Number.isFinite(Number(argv[topAt + 1])) ? Number(argv[topAt + 1]) : 40;
+const argv = process.argv.slice(2)
+const asJson = argv.includes("--json")
+const topAt = argv.indexOf("--top")
+const TOP = topAt >= 0 && Number.isFinite(Number(argv[topAt + 1])) ? Number(argv[topAt + 1]) : 40
 
 /**
  * Everything after `--` is the command to profile. The default is the suite as
  * CI runs it, minus the build: `npm test` would rebuild `dist/` first, and a
  * `tsc` run is not what this is measuring.
  */
-const dashdash = argv.indexOf("--");
-const command = dashdash >= 0 && argv.length > dashdash + 1 ? argv.slice(dashdash + 1) : ["node", "tests/run.js"];
+const dashdash = argv.indexOf("--")
+const command =
+  dashdash >= 0 && argv.length > dashdash + 1 ? argv.slice(dashdash + 1) : ["node", "tests/run.js"]
 
 /**
  * One row per line the child printed, with `dt` the gap since the line before
@@ -54,26 +55,26 @@ const command = dashdash >= 0 && argv.length > dashdash + 1 ? argv.slice(dashdas
  * check in the log, and `t` is kept as well as `dt` because "which minute of
  * the run was this" is how a reader locates a slow block.
  */
-const rows = [];
-const t0 = process.hrtime.bigint();
-let last = 0;
-let buffered = "";
+const rows = []
+const t0 = process.hrtime.bigint()
+let last = 0
+let buffered = ""
 
 const takeLine = (line) => {
-  const t = Number(process.hrtime.bigint() - t0) / 1e6;
-  rows.push({ t, dt: t - last, text: line });
-  last = t;
-};
+  const t = Number(process.hrtime.bigint() - t0) / 1e6
+  rows.push({ t, dt: t - last, text: line })
+  last = t
+}
 
 const onData = (data) => {
-  buffered += data;
-  let i = buffered.indexOf("\n");
+  buffered += data
+  let i = buffered.indexOf("\n")
   while (i >= 0) {
-    takeLine(buffered.slice(0, i));
-    buffered = buffered.slice(i + 1);
-    i = buffered.indexOf("\n");
+    takeLine(buffered.slice(0, i))
+    buffered = buffered.slice(i + 1)
+    i = buffered.indexOf("\n")
   }
-};
+}
 
 /**
  * A heartbeat on stderr, because the tables below cannot be printed until the
@@ -83,27 +84,29 @@ const onData = (data) => {
  * the oracles working or the run wedged.
  */
 const heartbeat = setInterval(() => {
-  const latest = rows.length > 0 ? rows[rows.length - 1].text.slice(0, 72) : "nothing printed yet";
-  const elapsed = (Number(process.hrtime.bigint() - t0) / 1e9).toFixed(0);
-  process.stderr.write(`[ci-profile] ${elapsed}s, ${rows.length} lines: ${latest}\n`);
-}, 30_000);
-heartbeat.unref();
-
-const child = spawn(command[0], command.slice(1), { stdio: ["ignore", "pipe", "pipe"] });
-child.stdout.setEncoding("utf8");
-child.stderr.setEncoding("utf8");
-child.stdout.on("data", onData);
-child.stderr.on("data", onData);
+  const latest = rows.length > 0 ? rows[rows.length - 1].text.slice(0, 72) : "nothing printed yet"
+  const elapsed = (Number(process.hrtime.bigint() - t0) / 1e9).toFixed(0)
+  process.stderr.write(`[ci-profile] ${elapsed}s, ${rows.length} lines: ${latest}\n`)
+}, 30_000)
+heartbeat.unref()
+
+const child = spawn(command[0], command.slice(1), { stdio: ["ignore", "pipe", "pipe"] })
+child.stdout.setEncoding("utf8")
+child.stderr.setEncoding("utf8")
+child.stdout.on("data", onData)
+child.stderr.on("data", onData)
 
 const status = await new Promise((resolve) => {
-  child.on("close", (code) => resolve(code ?? 1));
+  child.on("close", (code) => resolve(code ?? 1))
   child.on("error", (err) => {
-    console.error(`could not run ${command.join(" ")}: ${err.message}`);
-    resolve(1);
-  });
-});
-clearInterval(heartbeat);
-if (buffered.length > 0) takeLine(buffered);
+    console.error(`could not run ${command.join(" ")}: ${err.message}`)
+    resolve(1)
+  })
+})
+clearInterval(heartbeat)
+if (buffered.length > 0) {
+  takeLine(buffered)
+}
 
 /**
  * A check's name up to its first colon, which is how this suite names a family:
@@ -113,23 +116,23 @@ if (buffered.length > 0) takeLine(buffered);
  * keep the oracles — each of which prints one long line — apart.
  */
 const familyOf = (text) => {
-  const body = text.replace(/^(PASS|FAIL|SKIP)\s+/, "");
-  const colon = body.indexOf(":");
-  return colon > 0 ? body.slice(0, colon) : body.slice(0, 40);
-};
+  const body = text.replace(/^(PASS|FAIL|SKIP)\s+/, "")
+  const colon = body.indexOf(":")
+  return colon > 0 ? body.slice(0, colon) : body.slice(0, 40)
+}
 
-const families = new Map();
+const families = new Map()
 for (const row of rows) {
-  const key = familyOf(row.text);
-  const seen = families.get(key) ?? { ms: 0, lines: 0 };
-  seen.ms += row.dt;
-  seen.lines += 1;
-  families.set(key, seen);
+  const key = familyOf(row.text)
+  const seen = families.get(key) ?? { ms: 0, lines: 0 }
+  seen.ms += row.dt
+  seen.lines += 1
+  families.set(key, seen)
 }
 
-const total = rows.length > 0 ? rows[rows.length - 1].t : 0;
-const byCost = [...rows].sort((a, b) => b.dt - a.dt).slice(0, TOP);
-const byFamily = [...families].sort((a, b) => b[1].ms - a[1].ms).slice(0, TOP);
+const total = rows.length > 0 ? rows[rows.length - 1].t : 0
+const byCost = [...rows].sort((a, b) => b.dt - a.dt).slice(0, TOP)
+const byFamily = [...families].sort((a, b) => b[1].ms - a[1].ms).slice(0, TOP)
 
 if (asJson) {
   console.log(
@@ -145,14 +148,14 @@ if (asJson) {
       null,
       2
     )
-  );
-  process.exit(status);
+  )
+  process.exit(status)
 }
 
-const secs = (ms) => `${(ms / 1000).toFixed(1)}s`.padStart(8);
+const secs = (ms) => `${(ms / 1000).toFixed(1)}s`.padStart(8)
 
-console.log(`\n${command.join(" ")}`);
-console.log(`exit ${status} — ${secs(total).trim()} of wall clock over ${rows.length} printed lines\n`);
+console.log(`\n${command.join(" ")}`)
+console.log(`exit ${status} — ${secs(total).trim()} of wall clock over ${rows.length} printed lines\n`)
 
 /**
  * The run's own verdict, echoed verbatim.
@@ -164,25 +167,34 @@ console.log(`exit ${status} — ${secs(total).trim()} of wall clock over ${rows.
  * the exit status the thing to do). So the summary is printed before the
  * timings, where it cannot be missed.
  */
-const verdict = rows.filter((r) => r.text.trim().length > 0).slice(-3);
+const verdict = rows.filter((r) => r.text.trim().length > 0).slice(-3)
 if (verdict.length > 0) {
-  console.log("=== what the run itself reported ===");
-  for (const row of verdict) console.log(`  ${row.text}`);
-  console.log("");
+  console.log("=== what the run itself reported ===")
+  for (const row of verdict) {
+    console.log(`  ${row.text}`)
+  }
+  console.log("")
 }
 
-console.log(`=== the ${byCost.length} most expensive checks (cost = the gap before the line was printed) ===`);
-for (const row of byCost) console.log(`${secs(row.dt)}  at ${secs(row.t)}  ${row.text.slice(0, 104)}`);
+console.log(`=== the ${byCost.length} most expensive checks (cost = the gap before the line was printed) ===`)
+for (const row of byCost) {
+  console.log(`${secs(row.dt)}  at ${secs(row.t)}  ${row.text.slice(0, 104)}`)
+}
 
-console.log(`\n=== the ${byFamily.length} most expensive families (cumulative) ===`);
-for (const [name, f] of byFamily) console.log(`${secs(f.ms)}  ${String(f.lines).padStart(5)} line(s)  ${name.slice(0, 84)}`);
+console.log(`\n=== the ${byFamily.length} most expensive families (cumulative) ===`)
+for (const [name, f] of byFamily) {
+  console.log(`${secs(f.ms)}  ${String(f.lines).padStart(5)} line(s)  ${name.slice(0, 84)}`)
+}
 
 /**
  * The share the expensive tail accounts for, because "the top ten are 70% of
  * the run" is the sentence that decides whether to optimise a check or the
  * shape of the job around it.
  */
-const topTen = [...rows].sort((a, b) => b.dt - a.dt).slice(0, 10).reduce((sum, r) => sum + r.dt, 0);
-console.log(`\nthe ten most expensive checks are ${((topTen / total) * 100).toFixed(0)}% of the run.`);
+const topTen = [...rows]
+  .sort((a, b) => b.dt - a.dt)
+  .slice(0, 10)
+  .reduce((sum, r) => sum + r.dt, 0)
+console.log(`\nthe ten most expensive checks are ${((topTen / total) * 100).toFixed(0)}% of the run.`)
 
-process.exit(status);
+process.exit(status)

package/scripts/codes-registry.js

@@ -1,10 +1,10 @@
 /**
  * The diagnostic-code registry, read back out of a `codes.ts`.
  *
- * `self/codes.ts` holds the table -- a fragment line, then the `NL####` line
+ * `src/codes.ts` holds the table -- a fragment line, then the `NL####` line
  * that names its rule. Three places in this repository read it back:
  * `scripts/gen-diagnostic-codes.mjs`, which checks the registry's shape, its
- * order and that no number is used twice; `tests/diagnostic_coverage.js`,
+ * order and that no number is used twice; `tests/diagnostic-coverage.js`,
  * which asks which codes the suite reaches; and the `codes:` checks in
  * `tests/run.js`. This module is that parse, once, so the copies cannot drift
  * apart again ([issue #96](https://github.com/amritk/nish/issues/96)).
@@ -22,7 +22,7 @@
  * Two properties are the whole point of having it, and both are here because
  * they have failed:
  *
- *   - **The indentation is not part of the contract.** `self/codes.ts` lost a
+ *   - **The indentation is not part of the contract.** `src/codes.ts` lost a
  *     level when WP22 stage C rewrote its tables as arrows with concise
  *     bodies, and every reader keyed on four literal spaces then read it as
  *     *empty* rather than as changed. `^\s+` is what a pair is recognised by.
@@ -31,17 +31,29 @@
  *     codes" the same answer, which is what let the first instance of this
  *     survive unnoticed. This one raises instead.
  */
-import fs from "node:fs";
-import path from "node:path";
+import fs from "node:fs"
+import path from "node:path"
 
-const root = path.resolve(import.meta.dirname, "..");
+const root = path.resolve(import.meta.dirname, "..")
+
+/**
+ * One string literal in either quote: the formatter writes a fragment that
+ * holds a `"` with single quotes, because that needs no escape.
+ */
+export const STRING_LITERAL = /"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/g
 
 /**
  * One entry of the emitted table: the quoted fragment on its own line, then
  * the code on the next. Anchored to the line rather than to a column, for the
  * reason in the header.
  */
-const PAIR = /^\s+("(?:[^"\\]|\\.)*"),\n\s+"(NL\d{4})",$/gm;
+const PAIR = new RegExp(`^\\s+(${STRING_LITERAL.source}),\\n\\s+"(NL\\d{4})",$`, "gm")
+
+/** The text of a string literal in either quote, as JavaScript reads it. */
+const unquote = (literal) =>
+  literal.startsWith("'")
+    ? JSON.parse(`"${literal.slice(1, -1).replaceAll("\\'", "'").replaceAll('"', '\\"')}"`)
+    : JSON.parse(literal)
 
 /**
  * Every `{ fragment, code }` of one registry file, in the order the file holds
@@ -58,16 +70,16 @@ const PAIR = /^\s+("(?:[^"\\]|\\.)*"),\n\s+"(NL\d{4})",$/gm;
  * message names the text by.
  */
 export const parseCodesRegistry = (text, label) => {
-  const pairs = [];
+  const pairs = []
   for (const m of text.matchAll(PAIR)) {
-    pairs.push({ fragment: JSON.parse(m[1]), code: m[2] });
+    pairs.push({ fragment: unquote(m[1]), code: m[2] })
   }
   if (pairs.length === 0) {
-    throw new Error(`${label}: no diagnostic codes parsed -- the registry's shape has moved`);
+    throw new Error(`${label}: no diagnostic codes parsed -- the registry's shape has moved`)
   }
-  return pairs;
-};
+  return pairs
+}
 
 /** The same, for a registry on disk. The three callers all read a file. */
 export const readCodesRegistry = (file) =>
-  parseCodesRegistry(fs.readFileSync(file, "utf8"), path.relative(root, file));
+  parseCodesRegistry(fs.readFileSync(file, "utf8"), path.relative(root, file))

package/scripts/gen-diagnostic-codes.mjs

@@ -10,13 +10,14 @@
  * with one line broken to show that each rule below is really enforced.
  *
  * **The registry is kept by hand now.** It used to be generated: this script
- * scanned `src/` for every diagnostic message, cut each at its interpolations,
- * and wrote the same table into `src/codes.ts` and `self/codes.ts`. That scan
+ * scanned stage0's `src/` for every diagnostic message, cut each at its interpolations,
+ * and wrote the same table into stage0's `src/codes.ts` and this compiler's `self/codes.ts`
+ * (now `src/codes.ts`). That scan
  * read stage0's source, and stage0 is deleted (wp19 §5 R6), so the generator
- * was frozen with the table it last wrote and `self/codes.ts` became the
+ * was frozen with the table it last wrote and `src/codes.ts` became the
  * registry. A new diagnostic gets its code by hand: append a fragment and the
  * next free number in its band (the second mode above prints those), at the
- * position the ordering rule below puts it. `tests/diagnostic_coverage.js`
+ * position the ordering rule below puts it. `tests/diagnostic-coverage.js`
  * is what notices a diagnostic that has no code, by counting `NL0000`.
  *
  * What `--check` still holds, because each is what makes a code worth keying
@@ -24,10 +25,12 @@
  *
  *   - **Every number is well-formed and in its band.** `NL1xxx` Phase 0,
  *     `NL2xxx` the checker, `NL3xxx` the driver, `NL4xxx` the interop
- *     sidecars, `NL9xxx` a WP15 section 8 performance warning. Band 0 is not
- *     in the tables: `NL0000` (no rule matched), `NL0001` (a syntax error),
- *     `NL0002` (the toolchain) and `NL0003` (an internal error) are constants.
- *     A performance fragment is in `performanceRules` and nowhere else.
+ *     sidecars, `NL8xxx` a WP33 portability warning, `NL9xxx` a WP15 section
+ *     8 performance warning. Band 0 is not in the tables: `NL0000` (no rule
+ *     matched), `NL0001` (a syntax error), `NL0002` (the toolchain) and
+ *     `NL0003` (an internal error) are constants. A performance fragment is in
+ *     `performanceRules` and nowhere else, and a portability fragment is in
+ *     `portabilityRules` and nowhere else.
  *   - **Nothing is used twice.** A number handed out once is never handed to a
  *     different rule, and a retired rule keeps its entry -- it matches nothing,
  *     so carrying it costs a string -- precisely so that its number stays
@@ -39,7 +42,7 @@
  *   - **No fragment too short to identify a rule** (ten characters, trimmed),
  *     which would match half the suite.
  *   - **Every string in a table is half of a pair.** `codeFor` in
- *     `self/codes.ts` reads each table as one flat array and steps through it
+ *     `src/codes.ts` reads each table as one flat array and steps through it
  *     by two, so a fragment added without its code line -- or a code without
  *     its fragment -- shifts every pairing after it, and from there on
  *     messages get their neighbour's code. The pair reader cannot see that:
@@ -47,7 +50,8 @@
  *     simply not a match. So each table's strings are counted on their own
  *     and have to come to twice its pairs ([#107](https://github.com/amritk/nish/issues/107)).
  *   - **The `NL9xxx` codes run from `NL9001` with no gap**, one per WP15
- *     section 8 rule, so a missing number is a rule that lost its code.
+ *     section 8 rule, so a missing number is a rule that lost its code; and
+ *     the `NL8xxx` codes run from `NL8001` the same way, one per WP33 row.
  *   - **`RULE_COUNT` is the number of entries.**
  *
  * A fragment is the longest literal run of its message's template -- the rule
@@ -57,32 +61,49 @@
  * before the name, never the name, so `branding.ts` stays the only place it is
  * spelled (rule 5 in `.claude/orientation.md`). Keep to that when adding one.
  */
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { parseCodesRegistry } from "./codes-registry.js";
+import fs from "node:fs"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import { parseCodesRegistry, STRING_LITERAL } from "./codes-registry.js"
 
-const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-const REGISTRY = process.argv.slice(2).find((arg) => !arg.startsWith("--")) ?? path.join(ROOT, "self", "codes.ts");
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+const REGISTRY =
+  process.argv.slice(2).find((arg) => !arg.startsWith("--")) ?? path.join(ROOT, "src", "codes.ts")
 
 /** The bands a table entry may use. Band 0 is constants, never a table row. */
-const BANDS = new Set(["1", "2", "3", "4", "9"]);
+const BANDS = new Set(["1", "2", "3", "4", "8", "9"])
 
 /** Shorter than this, a fragment would match half the suite. */
-const MIN_FRAGMENT = 10;
+const MIN_FRAGMENT = 10
 
 /**
- * The text of one table in `self/codes.ts`: from its `name = (): string[] => [`
+ * The three tables, the band each warning table owns alone, and that warning
+ * class's name: a warning table holds only its band's codes and its band's
+ * codes live only there, because `codeFor` matches a warning's message against
+ * its own table and nothing else. `null` is the table of errors, which takes
+ * every other band.
+ */
+const TABLES = [
+  ["diagnosticRules", null, null],
+  ["portabilityRules", "8", "portability"],
+  ["performanceRules", "9", "performance"],
+]
+
+/**
+ * The text of one table in `src/codes.ts`: from its `name = (): string[] => [`
  * to the `];` that closes it. Parsed per table, because the table a fragment
  * sits in is part of what it means -- a performance rule is matched only
  * against a performance message.
  */
 const tableText = (text, name) => {
-  const open = text.indexOf(`export const ${name} = (): string[] => [`);
-  if (open < 0) return null;
-  const close = text.indexOf("\n];", open);
-  return close < 0 ? null : text.slice(open, close + 1);
-};
+  const header = new RegExp(`^(?:export )?const ${name} = \\(\\): string\\[\\] => \\[`, "m").exec(text)
+  const open = header === null ? -1 : header.index
+  if (open < 0) {
+    return null
+  }
+  const close = text.indexOf("\n]", open)
+  return close < 0 ? null : text.slice(open, close + 1)
+}
 
 /**
  * How many strings one table holds: every literal after the line that opens
@@ -90,110 +111,128 @@ const tableText = (text, name) => {
  * its own rather than read off the pairs -- a stray literal is exactly what
  * the pair reader skips.
  */
-const STRING = /"(?:[^"\\]|\\.)*"/g;
-const literalCount = (body) => body.slice(body.indexOf("\n")).match(STRING)?.length ?? 0;
+const literalCount = (body) => body.slice(body.indexOf("\n")).match(STRING_LITERAL)?.length ?? 0
 
 /** The order the compilers rely on: longest fragment first, then `localeCompare`. */
-const inOrder = (a, b) => b.fragment.length - a.fragment.length || a.fragment.localeCompare(b.fragment);
+const inOrder = (a, b) => b.fragment.length - a.fragment.length || a.fragment.localeCompare(b.fragment)
 
-/** Every rule of `self/codes.ts` it breaks, as a line each; empty when it holds. */
+/** Every rule of `src/codes.ts` it breaks, as a line each; empty when it holds. */
 const problems = (text) => {
-  const found = [];
-  const tables = [];
-  for (const [name, perf] of [
-    ["diagnosticRules", false],
-    ["performanceRules", true],
-  ]) {
-    const body = tableText(text, name);
+  const found = []
+  const tables = []
+  for (const [name, owns, kind] of TABLES) {
+    const body = tableText(text, name)
     if (body === null) {
-      found.push(`self/codes.ts has no \`${name}\` table`);
-      continue;
+      found.push(`src/codes.ts has no \`${name}\` table`)
+      continue
     }
     try {
-      const pairs = parseCodesRegistry(body, `self/codes.ts ${name}`);
-      const literals = literalCount(body);
+      const pairs = parseCodesRegistry(body, `src/codes.ts ${name}`)
+      const literals = literalCount(body)
       if (literals !== 2 * pairs.length) {
         found.push(
           `\`${name}\` holds ${literals} strings and ${pairs.length} fragment/code pairs: a string ` +
             "without its other half shifts every later pairing `codeFor` makes"
-        );
+        )
       }
-      tables.push({ name, perf, pairs });
+      tables.push({ name, owns, kind, pairs })
     } catch (err) {
-      found.push(err.message);
+      found.push(err.message)
     }
   }
-  const all = tables.flatMap((t) => t.pairs);
+  const all = tables.flatMap((t) => t.pairs)
 
   // The tables are the whole registry: a pair the reader finds outside them is
   // one the compilers never match, and one of theirs the reader misses is one
-  // `tests/diagnostic_coverage.js` never asks about.
-  let whole = [];
+  // `tests/diagnostic-coverage.js` never asks about.
+  let whole = []
   try {
-    whole = parseCodesRegistry(text, "self/codes.ts");
+    whole = parseCodesRegistry(text, "src/codes.ts")
   } catch (err) {
-    found.push(err.message);
+    found.push(err.message)
   }
   if (whole.length !== all.length) {
-    found.push(`self/codes.ts holds ${whole.length} pairs, ${all.length} of them inside the two tables`);
+    found.push(`src/codes.ts holds ${whole.length} pairs, ${all.length} of them inside the three tables`)
   }
 
-  for (const { name, perf, pairs } of tables) {
+  const warningBands = TABLES.map(([, owns]) => owns).filter((band) => band !== null)
+  for (const { name, owns, pairs } of tables) {
     for (let i = 0; i < pairs.length; i++) {
-      const { fragment, code } = pairs[i];
-      const band = code[2];
-      if (!BANDS.has(band)) found.push(`${code} is not in a table band (1, 2, 3, 4 or 9): ${JSON.stringify(fragment)}`);
-      if (perf !== (band === "9")) {
-        found.push(`${code} is in \`${name}\`, which holds ${perf ? "only" : "no"} NL9xxx codes`);
+      const { fragment, code } = pairs[i]
+      const band = code[2]
+      if (!BANDS.has(band)) {
+        found.push(`${code} is not in a table band (1, 2, 3, 4, 8 or 9): ${JSON.stringify(fragment)}`)
+      }
+      if (owns !== null && band !== owns) {
+        found.push(`${code} is in \`${name}\`, which holds only NL${owns}xxx codes`)
+      }
+      if (owns === null && warningBands.includes(band)) {
+        found.push(`${code} is in \`${name}\`, which holds no NL${band}xxx codes`)
       }
       if (fragment.trim().length < MIN_FRAGMENT) {
-        found.push(`${code}'s fragment ${JSON.stringify(fragment)} is under ${MIN_FRAGMENT} characters`);
+        found.push(`${code}'s fragment ${JSON.stringify(fragment)} is under ${MIN_FRAGMENT} characters`)
       }
       if (i > 0 && inOrder(pairs[i - 1], pairs[i]) > 0) {
-        found.push(`${code} is out of order in \`${name}\`: it has to come before ${pairs[i - 1].code}`);
+        found.push(`${code} is out of order in \`${name}\`: it has to come before ${pairs[i - 1].code}`)
       }
     }
   }
 
-  const perfCodes = tables
-    .filter((t) => t.perf)
-    .flatMap((t) => t.pairs.map((p) => Number(p.code.slice(3))))
-    .sort((a, b) => a - b);
-  const gap = perfCodes.findIndex((n, i) => n !== i + 1);
-  if (gap >= 0) {
-    found.push(`\`performanceRules\` has no NL${9000 + gap + 1} in its place: its codes run from NL9001 with no gap`);
+  // A warning band is gap-free from its first number, so a missing one is a
+  // rule that lost its code rather than a number nobody took yet.
+  for (const { name, owns, kind, pairs } of tables) {
+    if (owns === null) {
+      continue
+    }
+    const numbers = pairs.map((p) => Number(p.code.slice(3))).sort((a, b) => a - b)
+    const gap = numbers.findIndex((n, i) => n !== i + 1)
+    if (gap >= 0) {
+      const base = Number(owns) * 1000
+      found.push(
+        `\`${name}\` has no NL${base + gap + 1} in its place: its ${kind} codes run from NL${base + 1} with no gap`
+      )
+    }
   }
 
   const seen = (key) => {
-    const counts = new Map();
-    for (const pair of all) counts.set(pair[key], (counts.get(pair[key]) ?? 0) + 1);
-    return [...counts].filter(([, n]) => n > 1).map(([value]) => value);
-  };
-  for (const code of seen("code")) found.push(`${code} names two rules`);
-  for (const fragment of seen("fragment")) found.push(`${JSON.stringify(fragment)} has two entries`);
-
-  const count = /export const RULE_COUNT: i32 = (\d+);/.exec(text);
-  if (count === null) found.push("self/codes.ts has no `RULE_COUNT`");
-  else if (Number(count[1]) !== all.length) {
-    found.push(`RULE_COUNT is ${count[1]} and the tables hold ${all.length} rules`);
+    const counts = new Map()
+    for (const pair of all) {
+      counts.set(pair[key], (counts.get(pair[key]) ?? 0) + 1)
+    }
+    return [...counts].filter(([, n]) => n > 1).map(([value]) => value)
+  }
+  for (const code of seen("code")) {
+    found.push(`${code} names two rules`)
+  }
+  for (const fragment of seen("fragment")) {
+    found.push(`${JSON.stringify(fragment)} has two entries`)
+  }
+
+  const count = /export const RULE_COUNT: i32 = (\d+);?$/m.exec(text)
+  if (count === null) {
+    found.push("src/codes.ts has no `RULE_COUNT`")
+  } else if (Number(count[1]) !== all.length) {
+    found.push(`RULE_COUNT is ${count[1]} and the tables hold ${all.length} rules`)
   }
 
-  return { found, all };
-};
+  return { found, all }
+}
 
 /** The next number nobody has held, per band -- what a hand-added rule takes. */
 const nextFree = (pairs) => {
-  const highest = new Map();
+  const highest = new Map()
   for (const { code } of pairs) {
-    const band = code[2];
-    highest.set(band, Math.max(highest.get(band) ?? 0, Number(code.slice(3))));
+    const band = code[2]
+    highest.set(band, Math.max(highest.get(band) ?? 0, Number(code.slice(3))))
   }
-  return [...BANDS].map((band) => `NL${band}${String((highest.get(band) ?? 0) + 1).padStart(3, "0")}`);
-};
+  return [...BANDS].map((band) => `NL${band}${String((highest.get(band) ?? 0) + 1).padStart(3, "0")}`)
+}
 
-const { found, all } = problems(fs.readFileSync(REGISTRY, "utf8"));
-for (const problem of found) console.error(`error: ${problem}`);
+const { found, all } = problems(fs.readFileSync(REGISTRY, "utf8"))
+for (const problem of found) {
+  console.error(`error: ${problem}`)
+}
 if (found.length === 0 && !process.argv.includes("--check")) {
-  console.log(`self/codes.ts: ${all.length} rules, well-formed; next free: ${nextFree(all).join(" ")}`);
+  console.log(`src/codes.ts: ${all.length} rules, well-formed; next free: ${nextFree(all).join(" ")}`)
 }
-process.exit(found.length > 0 ? 1 : 0);
+process.exit(found.length > 0 ? 1 : 0)

package/scripts/nish-compiler.sh

@@ -1,3 +1,4 @@
+# shellcheck shell=bash
 # Sourced, not run: how a shell script turns a compiler path into a command.
 #
 #   . scripts/nish-compiler.sh
@@ -9,6 +10,7 @@
 # scripts/bootstrap.sh and tests/self/seed.js follows as `NODE_ENTRY`, so one
 # path names a compiler the same way to every tool. Bash, because the answer is
 # an array: a compiler path with a space in it stays one word.
+# shellcheck disable=SC2034 # `compiler` is the answer, read by the script that sourced this
 nish_compiler() {
   case "$1" in
     *.js | *.mjs | *.cjs) compiler=(node "$1") ;;