eyeprolog 1.4.2 → 1.4.3

package/package.json

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

package/src/iso.js

@@ -2623,10 +2623,53 @@ function validateControlCallable(term, culprit, env) {
     }
   }
 }
+function convertMetaCallBodyTerm(term, env, module) {
+  // ISO term-to-body conversion is applied when call/1 begins, before any
+  // goal in the converted body is executed. An unbound variable occurring as
+  // a body goal therefore becomes call(Var) at that point. If an earlier goal
+  // later binds Var to !, the resulting call(!) has its own opaque cut scope
+  // instead of turning into a textual cut in the enclosing meta-call.
+  //
+  // Build the converted control tree iteratively so a deeply nested sequence
+  // of conjunctions/disjunctions cannot consume the JavaScript call stack.
+  const convertNode = (input, inheritedModule) => {
+    const resolved = deref(input, env);
+    const effectiveModule = resolved.module ?? inheritedModule;
+    if (resolved.type === VAR) {
+      const wrapped = compound('call', [resolved]);
+      wrapped.module = effectiveModule;
+      return { term: wrapped, source: null, module: effectiveModule };
+    }
+    if (resolved.type !== ATOM && resolved.type !== COMPOUND) {
+      throw new PrologError('type_error(callable)', term);
+    }
+    if (resolved.type === COMPOUND && [',', ';', '->'].includes(resolved.name) && resolved.arity === 2) {
+      const converted = compound(resolved.name, [...resolved.args]);
+      converted.module = effectiveModule;
+      return { term: converted, source: resolved, module: effectiveModule };
+    }
+    return { term: resolved, source: null, module: effectiveModule };
+  };
+
+  const root = convertNode(term, module);
+  const pending = root.source == null ? [] : [root];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    for (let index = 0; index < 2; index++) {
+      const child = convertNode(current.source.args[index], current.module);
+      current.term.args[index] = child.term;
+      if (child.source != null) pending.push(child);
+    }
+  }
+  return root.term;
+}
+
 function expandCallGoal({ goal, env }) {
   const invoked = callable(goal.args[0], env);
-  if (invoked.module == null) invoked.module = goal.module ?? 'user';
-  return invoked;
+  const module = invoked.module ?? goal.module ?? 'user';
+  const converted = convertMetaCallBodyTerm(invoked, env, module);
+  if (converted.module == null) converted.module = module;
+  return converted;
 }
 function* callBuiltin(context) {
   const { solver, env } = context;

package/test/conformance/ISO-COMPLIANCE.md

@@ -36,7 +36,7 @@ relevant implementation-dependent overlap choice to an explicit audit outcome.
 | 7.4 — Prolog text and directives | covered | [ISO-PROLOG-TEXT-EXECUTION-MATRIX.md](ISO-PROLOG-TEXT-EXECUTION-MATRIX.md) closes the preparation/directive rows: declaration semantics, source clauses, cross-text operators/character conversion/flags, initialization order/lifetime, `include/1`, and one-time `ensure_loaded/1`, with implementation-defined cross-text choices indexed under 5.4. |
 | 7.5-7.6 — database and term/clause conversion | covered | [ISO-PROLOG-TEXT-EXECUTION-MATRIX.md](ISO-PROLOG-TEXT-EXECUTION-MATRIX.md) closes static/dynamic and private/public procedure semantics, clause order, logical-update visibility, empty/unknown lifetime, and term/body/clause conversion. Source and runtime assertion conversion recurse through `,/2`, `;/2`, and `->/2`, preserve variable identity, and protect standardized static/control procedures. |
 | 7.7 — execution and backtracking | covered | [ISO-PROLOG-TEXT-EXECUTION-MATRIX.md](ISO-PROLOG-TEXT-EXECUTION-MATRIX.md) closes ordinary clause selection/backtracking, source/database order, empty-versus-unknown procedures, logical-update visibility, and strict dispatch. EyeProlog automatic tabling, cycle guards, and recursive numeric shortcuts remain disabled in the strict profile. |
-| 7.8 — control constructs and exceptions | covered | [ISO-PROLOG-TEXT-EXECUTION-MATRIX.md](ISO-PROLOG-TEXT-EXECUTION-MATRIX.md) closes `true/0`, `fail/0`, `call/1`, cut, conjunction, disjunction, if-then(-else), and `catch/3`/`throw/1`, including Corrigendum 2 catchability of errors arising from the protected goal and Corrigendum 3 term-to-body conversion. The 8.15 built-in additions remain independently row-audited. |
+| 7.8 — control constructs and exceptions | covered | [ISO-PROLOG-TEXT-EXECUTION-MATRIX.md](ISO-PROLOG-TEXT-EXECUTION-MATRIX.md) closes `true/0`, `fail/0`, `call/1`, cut, conjunction, disjunction, if-then(-else), and `catch/3`/`throw/1`, including Corrigendum 2 catchability of errors arising from the protected goal and Corrigendum 3 term-to-body conversion at `call/1` entry; the regression suite pins the resulting cut scope when an initially unbound variable goal later becomes `!`. The 8.15 built-in additions remain independently row-audited. |
 | 7.9 — expression evaluation | covered | [ISO-EVALUABLE-FUNCTOR-MATRIX.md](ISO-EVALUABLE-FUNCTOR-MATRIX.md) closes recursive evaluation, direct-variable precedence, corrected non-evaluable `F/N` errors (including STC #69), operand template/type rules, mixed arithmetic-comparison conversion, exceptional values, and finite-host resource normalization. The audit also fixes float-only `float_integer_part/1` and `float_fractional_part/1` so even huge valid integers reach `type_error(float,...)` before any I->F overflow. |
 | 7.10 — input/output concepts | covered | Higher-level stream semantics are pinned for non-atom ground stream terms, alias lifetime, current/target stream selection and fallback, write truncation, append positioning, contradictory stream options, exact binary round-tripping, flushing, standard-stream close behavior, and repositioned overwrite. Term-output spelling is also checked lexically where ISO distinguishes token forms: Corrigendum 2 bar operators are written with bare `|`, ordinary atom/functor `|` remains quoted, and the semicolon name token is emitted bare by canonical output. The complete 8.11-8.14 built-in mode/error family remains row-audited in [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md), while all implementation-defined stream choices are indexed in [ISO-IMPLEMENTATION-DEFINED.md](ISO-IMPLEMENTATION-DEFINED.md). |
 | 7.11 — flags | covered | The complete Part 1 flag set, selected defaults, standard value domains, changeability, `current_prolog_flag/2`, and `set_prolog_flag/2` error behavior have dedicated strict tests. EyeProlog selects `bounded=false` and `integer_rounding_function=toward_zero`; valid alternative values of those fixed flags reach `permission_error(modify,flag,...)`, while `max_integer` and `min_integer` have no current value. STC #70 is recorded explicitly: EyeProlog has no separate finite procedure-arity ceiling, so the optional `max_procedure_arity` flag is absent while `max_arity` remains `unbounded`. Strict mode excludes the EyeProlog `occurs_check` extension. |

package/test/conformance/ISO-PROLOG-TEXT-EXECUTION-MATRIX.md

@@ -55,8 +55,12 @@ The complete 8.8-8.9 database built-in modes/errors remain covered by
 | 7.6.3 clause-to-term observation | covered | `clause/2` returns fresh renamed clause observations with the required sharing between head and body. |
 | 7.6.4 update conversion | covered | `asserta/1`, `assertz/1`, `retract/1`, and prepared source clauses use the same strict body-conversion rules and reject malformed bodies before database mutation. |
 
-Corrigendum 3's explicit `call/1` term-to-body wording is covered by the source
-and asserted-body conversion regressions.
+Corrigendum 3's explicit `call/1` term-to-body wording is covered by the source,
+asserted-body, and meta-call conversion regressions. In particular, `call/1`
+converts an initially unbound variable goal to `call(Var)` before execution; if
+an earlier goal later binds that variable to `!`, the resulting `call(!)` keeps
+its own opaque cut boundary instead of becoming a textual cut in the enclosing
+converted body.
 
 ## 7.7 - execution and backtracking
 
@@ -74,8 +78,8 @@ and asserted-body conversion regressions.
 | --- | --- | --- |
 | 7.8.1 `true/0` | covered | succeeds once |
 | 7.8.2 `fail/0` | covered | fails |
-| 7.8.3 `call/1` | covered | executes the converted goal; variables can become callable after earlier bindings; Corrigendum 3 term-to-body conversion is used |
-| 7.8.4 cut | covered | cut commits within its defined invocation scope; callee-local cuts do not incorrectly prune caller alternatives |
+| 7.8.3 `call/1` | covered | executes the converted goal; variables that are unbound at meta-call entry become `call(Var)` before execution, so a later binding to `!` remains an opaque `call(!)`; variables already bound at entry are dereferenced during conversion |
+| 7.8.4 cut | covered | cut commits within its defined invocation scope; callee-local cuts and cuts reached through a converted variable goal do not incorrectly prune alternatives outside that invocation |
 | 7.8.5 conjunction | covered | left-to-right execution and backtracking; nested malformed converted goals retain the whole control-term culprit |
 | 7.8.6 disjunction | covered | left branch is tried before the right and failure backtracks into the right branch |
 | 7.8.7 if-then | covered | successful condition commits to the selected condition solution before the then branch |

package/test/run-iso-strict.mjs

@@ -1214,6 +1214,21 @@ export function runIsoStrict(reporter = new TestReporter()) {
       isoStrict: true,
       goal: 'catch(throw(ball(X)),ball(Y),X=Y)',
     }).stats.completed_goal_lists > 0, true, 'throw/1 and catch/3 unify through a renamed thrown term');
+
+    const answerCount = (text) => {
+      const program = Program.parse('', { isoStrict: true });
+      const solver = new Solver(program, { isoStrict: true });
+      return [...solver.solve([parseGoalText(text, {
+        isoStrict: true,
+        operatorDefinitions: [...program.operators.values()],
+      })], new Env(), 0)].length;
+    };
+    equal(answerCount('call((Z=!, (X=1;X=2), Z)) ; T=end'), 3,
+      'call/1 converts an initially unbound variable goal before it can become a cut (issue #86)');
+    equal(answerCount('call((Z=!, (X=1;X=2), Z, X=2))'), 1,
+      'call(Var) cut remains opaque to choices made earlier in the converted body');
+    equal(answerCount('Z=!, (call(((X=1;X=2),Z)) ; T=end)'), 2,
+      'a variable already bound before call/1 conversion is dereferenced as a direct cut');
   });
 
   reporter.test('rejects EyeProlog module directives', () => {

package/test/run-regression.mjs

@@ -1116,6 +1116,31 @@ c4 ?- call((!;1)).
         assertEqual(result.stdout, 'quads: 22 run, 22 passed, 0 failed.\n', 'quad report');
       },
     },
+    {
+      name: 'call/1 converts variable goals before execution so later cuts stay opaque (issue #86)',
+      run: () => {
+        const quad = publicApi.runQuads(`?- call((Z = !,(X=1;X=2), Z)) ; T=end.\n` +
+          `   Z = !, X = 1\n` +
+          `;  Z = !, X = 2\n` +
+          `;  T = end.\n`);
+        assertEqual(quad.total, 1, 'issue #86 quad total');
+        assertEqual(quad.passed, 1, 'issue #86 exact answer sequence');
+        assertEqual(quad.failed, 0, 'issue #86 quad failures');
+
+        const program = Program.parse('');
+        const answerCount = (text) => {
+          const solver = new Solver(program, { registry: getEyePrologRegistry() });
+          return [...solver.solve([parseGoalText(text)], new Env(), 0)].length;
+        };
+
+        assertEqual(answerCount('call((Z=!, (X=1;X=2), Z)) ; T=end'), 3,
+          'issue #86 outer answer count');
+        assertEqual(answerCount('call((Z=!, (X=1;X=2), Z, X=2))'), 1,
+          'later call(!) does not prune the X=2 alternative');
+        assertEqual(answerCount('Z=!, (call(((X=1;X=2),Z)) ; T=end)'), 2,
+          'pre-bound cut stays direct inside the meta-call');
+      },
+    },
     {
       name: 'negation observes disjunction through direct and call/1 execution',
       run: () => {