eyeprolog 1.5.86 → 1.5.88

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.5.86",
+  "version": "1.5.88",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/src/quads.js

@@ -82,7 +82,7 @@ function checkDescription(program, quad, description, options, context) {
     if (part.type === ATOM && part.name === 'other_answer_sequence') {
       const previous = alternatives.at(-1);
       if (previous == null || unordered.has(previous)) {
-        return { ok: false, kind: 'malformed', expected: part };
+        return { ok: false, kind: 'malformed', expected: part, alternative: previous ?? undefined };
       }
       unordered.add(previous);
     } else alternatives.push(part);
@@ -93,7 +93,13 @@ function checkDescription(program, quad, description, options, context) {
     Number(alternativeDescribesLoop(right)) - Number(alternativeDescribesLoop(left)));
   for (const alternative of ordered) {
     const malformed = malformedAlternative(quad.query, alternative);
-    if (malformed != null) return { ok: false, kind: 'malformed', expected: malformed };
+    // Carry the whole offending `|`-alternative alongside the narrow
+    // sub-term the check actually tripped on: with several alternatives (the
+    // norm for `sto`-annotated queries -- see issue #112's follow-up),
+    // formatFailure shows this alternative in full and elides its siblings
+    // instead of leaving a reader to guess which branch a bare sub-term like
+    // `_B = [E|_B]` came from.
+    if (malformed != null) return { ok: false, kind: 'malformed', expected: malformed, alternative };
   }
   let unsupported = null;
   let undecided = null;
@@ -111,19 +117,19 @@ function checkAlternative(program, quad, alternative, options, context, unordere
   const requiresSto = leaves.some((leaf) => leaf.sto);
   const unsupported = leaves.find((leaf) => leaf.unsupported != null)?.unsupported;
   if (unsupported != null) {
-    return { ok: false, kind: 'unsupported', expected: unsupported };
+    return { ok: false, kind: 'unsupported', expected: unsupported, alternative };
   }
 
   // A permutation describes a complete sequence, not an arbitrary prefix or
   // a negative assertion. Do not silently weaken those annotations.
   if (unordered && leaves.some((leaf) => leaf.more || leaf.unexpected || leaf.sto ||
       leaf.waits || leaf.input != null || leaf.peek != null)) {
-    return { ok: false, kind: 'unsupported', expected: alternative };
+    return { ok: false, kind: 'unsupported', expected: alternative, alternative };
   }
 
   const ioLeaves = leaves.filter((leaf) => leaf.input != null || leaf.peek != null);
   if (ioLeaves.length > 1 || (ioLeaves.length > 0 && leaves.length !== 1)) {
-    return { ok: false, kind: 'malformed', expected: alternative };
+    return { ok: false, kind: 'malformed', expected: alternative, alternative };
   }
   const hasInputSpec = ioLeaves.length === 1;
   const inputLeaf = ioLeaves[0] ?? null;
@@ -986,6 +992,43 @@ const FAILURE_LABELS = {
   undecided: 'UNDECIDED',
 };
 
+// With several `|`-separated alternatives -- the norm for `sto`-annotated
+// queries -- a bare offending sub-term like `_B = [E|_B]` gives no sense of
+// which alternative it came from. Show that whole alternative in place, laid
+// out the same way the answer-description syntax itself lays out alternatives
+// and leaves (a leading `|` per alternative after the first, a leading `;`
+// per leaf after an alternative's first), and stand in for sibling
+// alternatives with a bare `...` rather than reproducing them (they were not
+// the problem) or dropping them silently (a reader can no longer tell how
+// many alternatives, or which one, this was) -- see issue #112's follow-up
+// (https://github.com/eyereasoner/eyeprolog/issues/112#issuecomment-5645403025).
+// Comments are not retained past parsing, so unlike a hand-written answer
+// description this reconstruction never has any to show. Returns null when
+// the description has only one alternative to begin with: there is then
+// nothing to elide, and the existing plain rendering already shows the whole
+// thing.
+function formatAlternativeContext(program, description, alternative) {
+  const parts = splitOperator(description, '|');
+  if (parts.length <= 1 || !parts.includes(alternative)) return null;
+  const lines = [];
+  parts.forEach((part, index) => {
+    const prefix = index === 0 ? '   ' : '|  ';
+    if (part !== alternative) {
+      lines.push(`${prefix}...`);
+      return;
+    }
+    splitOperator(part, ';').forEach((leaf, leafIndex) => {
+      lines.push(`${leafIndex === 0 ? prefix : ';  '}${formatQuadTerm(program, leaf)}`);
+    });
+  });
+  // A trailing `...` glued straight to a full stop reads as four dots; the
+  // answer-description syntax itself always writes a space before the period
+  // in that position (compare `..., ad_infinitum` with `... .`), so match it.
+  const last = lines.length - 1;
+  lines[last] = lines[last].endsWith('...') ? `${lines[last]} .` : `${lines[last]}.`;
+  return lines.join('\n');
+}
+
 function formatFailure(program, quad, result, description = quad.answers[0]) {
   const source = quad.source ?? { filename: '<input>', line: 1 };
   // Point at the failing answer description's own line rather than always the
@@ -995,9 +1038,21 @@ function formatFailure(program, quad, result, description = quad.answers[0]) {
   const label = quad.id == null ? '' : `${formatQuadTerm(program, quad.id)}, `;
   const reason = FAILURE_LABELS[result.kind] ?? 'FAILED';
   const expected = result.expected ?? description;
+  const context = result.alternative != null
+    ? formatAlternativeContext(program, description, result.alternative)
+    : null;
   const detail = result.kind === 'undecided'
     ? `   undecided: ${result.reason}.\n`
-    : `   expected: ${formatQuadTerm(program, expected)}.\n`;
+    // When the offending sub-term already *is* the whole alternative (an
+    // `expected:` line would just repeat the context lines), the context
+    // alone is the full, non-redundant report. formatAlternativeContext
+    // already lays out and terminates its own lines, so it needs no further
+    // wrapping here (unlike the plain single-line `expected:` case below).
+    : context != null && expected === result.alternative
+      ? `${context}\n`
+      : context != null
+        ? `${context}\n   expected: ${formatQuadTerm(program, expected)}.\n`
+        : `   expected: ${formatQuadTerm(program, expected)}.\n`;
   return `quads: ${reason} ${label}${source.filename}:${line}\n` +
     `   ?- ${formatQuadTerm(program, quad.query)}.\n` + detail;
 }

package/test/regression/cases-regression.mjs

@@ -2552,6 +2552,49 @@ c4 ?- call((!;1)).
         assertEqual(result.total, 1, 'quad total');
         assertEqual(result.failed, 1, 'quad failed');
         assertIncludes(result.stdout, 'quads: MALFORMED malformed-quad.pl:2', 'malformed report');
+        // A single `|`-alternative already is the whole answer description --
+        // there is nothing to elide, so the plain, unelided report is
+        // unchanged (contrast the multi-alternative case just below).
+        assertNotIncludes(result.stdout, ' | ', 'single-alternative report stays unelided');
+      },
+    },
+    {
+      name: 'runQuads shows a malformed sub-term in the context of its full sibling-elided alternative (issue #112)',
+      run: () => {
+        // Adapted from the upstream Prologue `select(E, Xs, Xs)` quad
+        // (https://github.com/eyereasoner/eyeprolog/issues/112#issuecomment-5645403025):
+        // a query-unrelated `Ys` stands in for the legitimate forward-reference
+        // idiom so this stays malformed regardless of that fix. With three
+        // `|`-alternatives, a bare `expected: Ys = [E|Ys].` gives no sense of
+        // which one it came from; the report should instead show that whole
+        // alternative in place and stand in for its siblings with `...`.
+        const source = `:- use_module(library(prologue)).
+?- select(E, Xs, Xs).
+   sto,
+   loops
+|  sto,
+   Xs = [E|Xs]
+;  Xs = [_A|_B], Ys = [E|Ys]
+;  ..., ad_infinitum
+|  sto,
+   Xs = [E,E|_A]
+;  Xs = [_A,E,E|_B]
+;  ..., ad_infinitum.
+`;
+        const result = publicApi.runQuads(Program.parseSources([{ text: source, filename: 'select-quad.pl' }]));
+        assertEqual(result.total, 1, 'quad total');
+        assertEqual(result.failed, 1, 'quad failed');
+        // Laid out the same way the answer-description syntax itself lays
+        // out alternatives (a leading `|`) and leaves (a leading `;`), per
+        // Ulrich's own proposed shape in that follow-up comment.
+        assertIncludes(result.stdout,
+          '   ...\n' +
+          '|  sto, Xs = [E | Xs]\n' +
+          ';  Xs = [_A | _B], Ys = [E | Ys]\n' +
+          ';  ..., ad_infinitum\n' +
+          '|  ... .\n',
+          'sibling-elided alternative context');
+        assertIncludes(result.stdout, '   expected: Ys = [E | Ys].\n', 'still-precise offending sub-term');
       },
     },
     {