eyeprolog 1.2.25 → 1.2.26

package/test/conformance/wg17-syntax-coverage.json

@@ -0,0 +1,18 @@
+{
+  "source": "https://www.complang.tuwien.ac.at/ulrich/iso-prolog/conformity_testing",
+  "checkedOn": "2026-08-15",
+  "upstream": {
+    "firstId": 1,
+    "lastId": 368,
+    "deletedIds": [20, 273],
+    "activeCases": 366
+  },
+  "evidence": [
+    {
+      "name": "complete offline executable matrix",
+      "path": "test/conformance/wg17-syntax-cases.json",
+      "link": "../run-wg17-syntax.mjs",
+      "ids": "all-active"
+    }
+  ]
+}

package/test/run-all.mjs

@@ -9,12 +9,14 @@ import { runIsoStrict } from './run-iso-strict.mjs';
 import { runPlayground } from './run-playground.mjs';
 import { runExamples } from './run-examples.mjs';
 import { runBookExamples } from './run-book-examples.mjs';
+import { runWg17Syntax } from './run-wg17-syntax.mjs';
 
 const reporter = new TestReporter();
 
 try {
   runConformance(reporter);
   runIsoStrict(reporter);
+  runWg17Syntax(reporter);
   runRegression(reporter);
   await runPlayground(reporter);
   runExamples(reporter);

package/test/run-regression.mjs

@@ -45,6 +45,7 @@ import { TestReporter, isMainModule } from './test-style.mjs';
 import { buildConformanceReport, formatConformanceReport } from './run-conformance-report.mjs';
 import { proofExamples } from './run-examples.mjs';
 import { goalsFromSource } from './goal-metadata.mjs';
+import { renderWg17SyntaxStatus } from '../tools/report-wg17-syntax-coverage.mjs';
 
 const testRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)));
 const packageRoot = path.resolve(testRoot, '..');
@@ -652,18 +653,18 @@ c4 ?- call((!;1)).
       },
     },
     {
-      name: 'number_chars uses one generated representation for floating-point zero',
+      name: 'number syntax and number_chars normalize floating-point negative zero',
       run: () => {
         const result = runCli([], {
           input: 'X = -0.0, number_chars(X,C), number_chars(Y,C), X == Y, number_chars(Y,D).\nhalt.\n',
         });
         assertEqual(result.status, 0, 'exit status');
-        assertIncludes(result.stdout, "X = -0.0, C = ['0', '.', '0'], Y = 0.0, D = ['0', '.', '0'].", 'answer');
+        assertIncludes(result.stdout, "X = 0.0, C = ['0', '.', '0'], Y = 0.0, D = ['0', '.', '0'].", 'answer');
         assertEqual(result.stderr, '', 'stderr');
       },
     },
     {
-      name: 'readers keep a full stop inside a character-code constant (WG17 #211)',
+      name: 'readers keep a full stop inside a character-code constant (WG17 #367)',
       run: () => {
         const streamResult = runEyeProlog('', {
           goal: 'read((46 = 46))',
@@ -675,6 +676,10 @@ c4 ?- call((!;1)).
         assertEqual(cliResult.status, 0, 'top-level character-code full stop status');
         assertIncludes(cliResult.stdout, 'X = 46', 'top-level character-code answer');
         assertNotIncludes(cliResult.stdout, 'syntax_error', 'top-level character-code syntax');
+
+        const upstreamResult = runCli([], { input: "writeq(0'. ).\nhalt.\n" });
+        assertEqual(upstreamResult.status, 0, 'WG17 #367 exit status');
+        assertIncludes(upstreamResult.stdout, '46 true.', 'WG17 #367 output');
       },
     },
     {
@@ -2052,6 +2057,13 @@ c4 ?- call((!;1)).
 
 function documentationSyncCases() {
   return [
+    {
+      name: 'WG17 syntax status matches its executable-coverage manifest',
+      run: () => {
+        const filename = path.join(testRoot, 'conformance', 'WG17-SYNTAX-STATUS.md');
+        assertEqual(fs.readFileSync(filename, 'utf8'), renderWg17SyntaxStatus(), 'WG17 syntax status');
+      },
+    },
     {
       name: 'book builtins match runtime registry',
       run: () => assertArrayEqual(bookBuiltinNames(), registeredBuiltinNames(), 'builtins'),

package/test/run-wg17-syntax.mjs

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+// Offline, one-by-one execution of the 366 active WG17 syntax cases. The
+// fixture is a dated snapshot of the public conformity-testing table, so the
+// release gate does not depend on the network or another Prolog system.
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  Env, Program, Solver, parseGoalText, run,
+} from '../src/index.js';
+import { TestReporter, isMainModule } from './test-style.mjs';
+
+const testRoot = path.dirname(fileURLToPath(import.meta.url));
+const fixturePath = path.join(testRoot, 'conformance', 'wg17-syntax-cases.json');
+
+function runnerStage(index, maximum) {
+  if (index > maximum) return `write('\\n<WG17-COMPLETE>')`;
+  return `read_term(G${index}, [variable_names(V${index})]), ` +
+    `(G${index} == end_of_file -> write('\\n<WG17-COMPLETE>') ; (` +
+    `write('\\n<WG17-BEGIN-${index}>'), call(G${index}), ` +
+    `write('<WG17-VARS>'), writeq(V${index}), write('<WG17-END>'), ` +
+    `${runnerStage(index + 1, maximum)}))`;
+}
+
+function capturedStages(stdout) {
+  const complete = stdout.indexOf('<WG17-COMPLETE>');
+  if (complete < 0) return null;
+  const captured = stdout.slice(0, complete);
+  return [...captured.matchAll(/<WG17-BEGIN-(\d+)>([\s\S]*?)<WG17-VARS>([\s\S]*?)<WG17-END>/g)]
+    .map((match) => ({ output: match[2], variables: match[3] }));
+}
+
+function executeFinite(item) {
+  try {
+    const result = run('', {
+      isoStrict: true,
+      goal: runnerStage(1, item.readCount),
+      ioOptions: { input: `${item.input}\n` },
+    });
+    const stages = capturedStages(result.stdout);
+    return stages == null ? { type: 'failure' } : { type: 'success', stages };
+  } catch (error) {
+    return { type: 'error', formal: error?.formal ?? null };
+  }
+}
+
+function executeWait(item) {
+  const program = Program.parse('', { isoStrict: true });
+  const solver = new Solver(program, {
+    isoStrict: true,
+    ioOptions: { input: item.input },
+  });
+  const stream = solver.io.resolve('user_input');
+  let requests = 0;
+  stream.interactiveReadTerm = () => {
+    requests++;
+    return null;
+  };
+  const goal = parseGoalText('read_term(G, [])', {
+    isoStrict: true,
+    operatorDefinitions: [...program.operators.values()],
+  });
+  try {
+    [...solver.solve([goal], new Env(), 0)];
+  } catch (_) {
+    // Returning null from the hook models EOF after EyeProlog has asked the
+    // interactive source for the continuation that the upstream case awaits.
+  }
+  return requests === 1 ? { type: 'waits' } : { type: 'did_not_wait', requests };
+}
+
+function assertOutcome(item) {
+  const actual = item.outcome.type === 'waits' ? executeWait(item) : executeFinite(item);
+  if (JSON.stringify(actual) !== JSON.stringify(item.outcome)) {
+    throw new Error(
+      `WG17 #${item.id} (${item.expected})\n` +
+      `expected ${JSON.stringify(item.outcome)}\n` +
+      `actual   ${JSON.stringify(actual)}`,
+    );
+  }
+}
+
+export function runWg17Syntax(reporter = new TestReporter()) {
+  const fixture = JSON.parse(fs.readFileSync(fixturePath, 'utf8'));
+  if (fixture.cases.length !== 366) {
+    throw new Error(`WG17 fixture has ${fixture.cases.length} cases instead of 366`);
+  }
+  const ids = new Set(fixture.cases.map(({ id }) => id));
+  if (ids.size !== 366 || ids.has(20) || ids.has(273)) {
+    throw new Error('WG17 fixture identifiers do not match the active upstream inventory');
+  }
+
+  reporter.section('WG17 syntax');
+  for (const item of fixture.cases) reporter.test(`#${item.id}`, () => assertOutcome(item));
+  reporter.sectionTotal('WG17 syntax');
+}
+
+if (isMainModule(import.meta.url)) {
+  const reporter = new TestReporter();
+  try {
+    runWg17Syntax(reporter);
+    reporter.totalLine();
+  } catch (_) {
+    process.exitCode = 1;
+  }
+}

package/tools/report-wg17-syntax-coverage.mjs

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+// Render the traceability status for the public WG17 syntax corpus. This is a
+// coverage ledger, not a claim that untraced cases fail or that traced cases
+// are the only local tests exercising the same language rules.
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const manifestPath = path.join(packageRoot, 'test', 'conformance', 'wg17-syntax-coverage.json');
+const statusPath = path.join(packageRoot, 'test', 'conformance', 'WG17-SYNTAX-STATUS.md');
+
+export function readWg17SyntaxCoverage() {
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  const { firstId, lastId, deletedIds, activeCases } = manifest.upstream;
+  const deleted = new Set(deletedIds);
+  const activeIds = [];
+  for (let id = firstId; id <= lastId; id++) if (!deleted.has(id)) activeIds.push(id);
+  if (activeIds.length !== activeCases) {
+    throw new Error(`WG17 active-case count is ${activeIds.length}, manifest says ${activeCases}`);
+  }
+
+  const active = new Set(activeIds);
+  const covered = new Set();
+  const evidenceEntries = [];
+  for (const evidence of manifest.evidence) {
+    if (!evidence.name || !evidence.path || !evidence.link ||
+        (!Array.isArray(evidence.ids) && evidence.ids !== 'all-active')) {
+      throw new Error('invalid WG17 evidence entry');
+    }
+    const evidenceIds = evidence.ids === 'all-active' ? activeIds : evidence.ids;
+    const evidenceFilename = path.join(packageRoot, evidence.path);
+    if (!fs.existsSync(evidenceFilename)) throw new Error(`missing WG17 evidence file ${evidence.path}`);
+    const referenced = referencedWg17Ids(fs.readFileSync(evidenceFilename, 'utf8'));
+    const withinEntry = new Set();
+    for (const id of evidenceIds) {
+      if (!Number.isInteger(id) || !active.has(id)) throw new Error(`invalid active WG17 id #${id}`);
+      if (withinEntry.has(id)) throw new Error(`duplicate WG17 id #${id} in ${evidence.name}`);
+      if (!referenced.has(id)) throw new Error(`WG17 id #${id} is not referenced by ${evidence.path}`);
+      withinEntry.add(id);
+      covered.add(id);
+    }
+    evidenceEntries.push({ ...evidence, ids: evidenceIds });
+  }
+
+  return {
+    manifest,
+    evidenceEntries,
+    activeIds,
+    coveredIds: activeIds.filter((id) => covered.has(id)),
+    untracedIds: activeIds.filter((id) => !covered.has(id)),
+  };
+}
+
+function referencedWg17Ids(source) {
+  const ids = new Set();
+  for (const match of source.matchAll(/#(\d+)(?:-(\d+))?/g)) {
+    const first = Number(match[1]);
+    const last = match[2] == null ? first : Number(match[2]);
+    for (let id = first; id <= last; id++) ids.add(id);
+  }
+  for (const match of source.matchAll(/"id"\s*:\s*(\d+)/g)) ids.add(Number(match[1]));
+  return ids;
+}
+
+export function renderWg17SyntaxStatus() {
+  const { manifest, evidenceEntries, activeIds, coveredIds, untracedIds } = readWg17SyntaxCoverage();
+  const percentage = (100 * coveredIds.length / activeIds.length).toFixed(1);
+  const evidenceRows = evidenceEntries.map((evidence) =>
+    `| [${evidence.name}](${evidence.link}) | ${evidence.ids.length} | ${formatRanges(evidence.ids)} |`);
+
+  return `# WG17 syntax traceability status
+
+Source: [Conformity Testing I: Syntax](${manifest.source})  
+Upstream inventory checked: ${manifest.checkedOn}
+
+This ledger counts an upstream case only when its WG17 identifier, query,
+expected ISO disposition, and observed EyeProlog outcome are stored in the
+offline executable matrix. Semantically similar parser tests are not inferred
+as coverage.
+
+## Current standing
+
+| Measure | Count |
+| --- | ---: |
+| Active upstream cases | ${activeIds.length} |
+| Executable EyeProlog dispositions | ${coveredIds.length} (${percentage}%) |
+| Not yet traced one-by-one | ${untracedIds.length} |
+| Deleted upstream identifiers | ${formatRanges(manifest.upstream.deletedIds)} |
+
+The matrix runs in strict ISO stream-reader mode as part of \`npm test\`. The
+three upstream \`waits\` cases are checked through EyeProlog's interactive input
+hook; the other ${activeIds.length - 3} cases are checked for their exact stored
+success output, bindings, failure, or ISO error category.
+
+## Traceable evidence
+
+| Executable evidence | Referenced IDs | WG17 cases |
+| --- | ---: | --- |
+${evidenceRows.join('\n')}
+
+The evidence groups overlap. Their union is **${coveredIds.length}** active cases:
+${formatRanges(coveredIds)}.
+
+## Untraced upstream identifiers
+
+${untracedIds.length === 0 ? 'None.' : `${formatRanges(untracedIds)}.`}
+
+## Maintenance
+
+1. Refresh the dated fixture when the upstream table changes.
+2. Review any changed ISO expectation before updating an observed snapshot.
+3. Keep this generated status page synchronized in the release gate.
+`;
+}
+
+function formatRanges(ids) {
+  const sorted = [...new Set(ids)].sort((left, right) => left - right);
+  const ranges = [];
+  for (let index = 0; index < sorted.length;) {
+    const start = sorted[index];
+    let end = start;
+    while (index + 1 < sorted.length && sorted[index + 1] === end + 1) end = sorted[++index];
+    ranges.push(start === end ? `#${start}` : `#${start}–#${end}`);
+    index++;
+  }
+  return ranges.join(', ');
+}
+
+if (process.argv[1] != null && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const rendered = renderWg17SyntaxStatus();
+  if (process.argv.includes('--check')) {
+    const current = fs.readFileSync(statusPath, 'utf8');
+    if (current !== rendered) {
+      process.stderr.write('WG17 syntax status is stale; run npm run report:wg17-syntax and update the file.\n');
+      process.exitCode = 1;
+    }
+  } else {
+    process.stdout.write(rendered);
+  }
+}