eyeprolog 1.6.3 → 1.6.4

package/package.json

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

package/src/cleanup.js

@@ -163,6 +163,13 @@ function closeSearchStack(stack, suppressErrors) {
   closeFrames(removed, suppressErrors);
 }
 
+// A caught exception discards only the protected goal's alternatives. Cleanup
+// must run before recovery, without replacing the exception being unwound.
+export function unwindSearchStack(stack, start) {
+  const removed = Array.prototype.splice.call(stack, start, stack.length - start);
+  closeFrames(removed, true);
+}
+
 function closeFrames(frames, suppressErrors) {
   let firstError = null;
   for (let index = frames.length - 1; index >= 0; index--) {

package/src/iso.js

@@ -141,7 +141,7 @@ const isoBuiltins = {
     for (let arity = 2; arity <= 8; arity++) {
       registry.add('call', arity, callClosureBuiltin, { expandGoal: expandCallClosureGoal });
     }
-    registry.add('catch', 3, catchBuiltin);
+    registry.add('catch', 3, catchBuiltin, { catchControl });
     registry.add('throw', 1, throwBuiltin, { deterministic: true });
     registry.add('\\+', 1, negationBuiltin, { deterministic: true });
     registry.add('once', 1, onceBuiltin, { deterministic: true });
@@ -3106,6 +3106,21 @@ function prologErrorBall(error) {
 }
 const catchBuiltin = pendingBuiltin(catchSolutions, true);
 
+// The solver runs protected goals on its explicit search stack. Keep ball
+// conversion and callable validation here, shared with the builtin semantics.
+const catchControl = {
+  prepare: ({ goal, env }) => callable(goal.args[0], env),
+  recover({ goal, env, error }) {
+    const ball = error instanceof ThrownTerm
+      ? error.term
+      : error instanceof PrologError ? prologErrorBall(error) : null;
+    if (ball == null) return null;
+    const recovered = env.clone();
+    if (!unify(goal.args[1], ball, recovered)) return null;
+    return { goal: callable(goal.args[2], recovered), env: recovered };
+  },
+};
+
 function* catchSolutions({ solver, goal, env }, state) {
   let child = null;
   try {
@@ -3297,6 +3312,7 @@ export class BuiltinRegistry {
       deterministic: options.deterministic ?? false,
       deterministicWhen: options.deterministicWhen ?? null,
       expandGoal: options.expandGoal ?? null,
+      catchControl: options.catchControl ?? null,
       ready: options.ready ?? null,
       fallbackWhenNotReady: options.fallbackWhenNotReady ?? false,
       shouldUse: options.shouldUse ?? null,

package/src/solver.js

@@ -7,6 +7,7 @@ import {
 } from './term.js';
 import { numberValueKey, sameNumberValue } from './number-value.js';
 import { attachBuiltinErrorContext } from './errors.js';
+import { unwindSearchStack } from './cleanup.js';
 import { PrologError, getStrictIsoRegistry } from './iso.js';
 import { getEyePrologRegistry } from './standard-library.js';
 import { selectClauseCandidates, selectClauseCandidatesForValues, selectGroundClauseCandidates } from './program-indexing.js';
@@ -462,7 +463,11 @@ export class Solver {
       const stack = [{ kind: 'goals', goals, env, depth, active: savedActive.slice() }];
       registeredStack = stack;
       this.solveStacks.push(stack);
+      let active = savedActive;
       while (stack.length) {
+      const frame = stack.pop();
+      active = frame.active ?? active;
+      try {
       this.inferences++;
       this.inferenceObservation.value++;
       this.checkMemoryLimit();
@@ -470,7 +475,6 @@ export class Solver {
         this.inferenceLimitExceeded = true;
         break;
       }
-      const frame = stack.pop();
       this.syncProgramRevision();
       if (frame.kind === 'resumeBuiltin') {
         if (this.solutionsSeen >= this.solutionLimit) continue;
@@ -623,7 +627,7 @@ export class Solver {
       env.setOccursCheckHandler(this.occursCheckHandler);
       env.setAttributeHookRunner(this.attributeHookRunner);
       depth = frame.depth;
-      let active = frame.active;
+      active = frame.active;
 
       while (true) {
         this.inferences++;
@@ -673,6 +677,12 @@ export class Solver {
         }
 
         const first = goals[0];
+        if (first?.kind === 'exitCatch') {
+          active = first.active;
+          depth = first.depth;
+          goals = first.goals;
+          continue;
+        }
         if (first?.kind === 'continueGoals') {
           if (first.releaseActive) active = active.slice(0, -1);
           depth = first.depth;
@@ -749,6 +759,27 @@ export class Solver {
         const def = callable ? this.lookupBuiltin(goal.name, goal.arity) : null;
         this.active = active;
         const builtinReady = def && builtinIsReadyOrAuthoritative(def, this, goal, env);
+        if (builtinReady && def.catchControl != null) {
+          // Backtracking frames retain this handler in their active path;
+          // exitCatch removes it before executing the caller's continuation.
+          // Nesting protected goals therefore needs no recursive solve() call.
+          const handler = {
+            goal, env: env.clone(), definition: def,
+            parentActive: active, goals: rest, depth,
+            searchStack: stack, stackDepth: stack.length,
+          };
+          active = [...active, handler];
+          let invoked;
+          try {
+            invoked = def.catchControl.prepare({ goal, env });
+          } catch (error) {
+            throw attachBuiltinErrorContext(error, def, goal);
+          }
+          goals = [invoked, { kind: 'exitCatch', active: handler.parentActive, goals: rest, depth }];
+          env = env.clone();
+          depth++;
+          continue;
+        }
         if (builtinReady && typeof def.expandGoal === 'function') {
           // Meta-calls execute in this continuation instead of hiding their
           // search behind a host-generator frame. Their real clause, control,
@@ -968,20 +999,43 @@ export class Solver {
         pushUserGoalUncachedFrames(stack, this, group, goal, rest, env, depth, active);
         break;
       }
-      }
-    } catch (error) {
-      const normalized = normalizeHostResourceError(error);
-      if (normalized instanceof PrologError && normalized.formal === 'resource_error(memory)') {
-        // Unwinding makes query-local terms unreachable, but hosts are free to
-        // postpone collection. Give the shared solver family bounded breathing
-        // room on its next query so a GC can observe those released references.
-        if (!this.memoryRecovery.active) {
-          this.memoryRecovery.active = true;
-          this.memoryRecovery.reservationBytes = 1024 * 1024;
-          this.memoryRecovery.checks = 16;
+      } catch (caught) {
+        let error = normalizeSolverResourceError(this, caught);
+        let recovered = false;
+        for (let index = active.length - 1; index >= 0; index--) {
+          const handler = active[index];
+          // Reentrant control builtins inherit active cut markers, but must
+          // propagate exceptions back to the solve() that owns the handler.
+          if (handler.searchStack !== stack) continue;
+          unwindSearchStack(stack, handler.stackDepth);
+          active = handler.parentActive;
+          let recovery;
+          try {
+            recovery = handler.definition.catchControl.recover({ ...handler, error });
+          } catch (replacement) {
+            error = attachBuiltinErrorContext(replacement, handler.definition, handler.goal);
+            index = active.length;
+            continue;
+          }
+          if (recovery == null) {
+            index = active.length;
+            continue;
+          }
+          // Recovery is outside this handler and has its own opaque cut scope.
+          const invocation = { goal: recovery.goal, env: recovery.env._snapshotForSolverRead() };
+          stack.push({
+            kind: 'goals',
+            goals: [recovery.goal, { kind: 'exitCatch', active, goals: handler.goals, depth: handler.depth }],
+            env: recovery.env, depth: handler.depth + 1, active: [...active, invocation],
+          });
+          recovered = true;
+          break;
         }
+        if (!recovered) throw error;
       }
-      throw normalized;
+      }
+    } catch (error) {
+      throw normalizeSolverResourceError(this, error);
     } finally {
       const stackIndex = this.solveStacks.indexOf(registeredStack);
       if (stackIndex >= 0) this.solveStacks.splice(stackIndex, 1);
@@ -1152,6 +1206,20 @@ export class Solver {
 
 }
 
+function normalizeSolverResourceError(solver, error) {
+  const normalized = normalizeHostResourceError(error);
+  if (normalized instanceof PrologError && normalized.formal === 'resource_error(memory)') {
+    // Leave bounded breathing room for recovery after abandoned query terms
+    // become garbage, including when a handler in this search catches the error.
+    if (!solver.memoryRecovery.active) {
+      solver.memoryRecovery.active = true;
+      solver.memoryRecovery.reservationBytes = 1024 * 1024;
+      solver.memoryRecovery.checks = 16;
+    }
+  }
+  return normalized;
+}
+
 function normalizeHostResourceError(error) {
   if (error?.name !== 'RangeError') return error;
   const message = String(error?.message ?? '');
@@ -1160,9 +1228,14 @@ function normalizeHostResourceError(error) {
   // with the resource atom implementation dependent.  A finite host capacity
   // ceiling is reported as `memory`; reserve `finite_memory` for the separate
   // convention where no finite amount of memory can complete the computation.
-  if (/^(?:Map|Set) maximum size exceeded$/.test(message)) {
+  // Do not run a regular expression here: V8 can overflow while compiling it
+  // on an already exhausted stack, masking the original error (issue #117).
+  if (message === 'Map maximum size exceeded' || message === 'Set maximum size exceeded') {
     return new PrologError('resource_error(memory)');
   }
+  if (message === 'Maximum call stack size exceeded') {
+    return new PrologError('resource_error(stack)');
+  }
   return error;
 }
 

package/test/regression/cases-api.mjs

@@ -1080,11 +1080,12 @@ answer(ok) :-
       },
     },
     {
-      name: 'host Map/Set capacity errors become resource_error(memory)',
+      name: 'host capacity and stack errors become Prolog resource errors',
       run: () => {
-        for (const [predicate, message] of [
-          ['exhaust_map', 'Map maximum size exceeded'],
-          ['exhaust_set', 'Set maximum size exceeded'],
+        for (const [predicate, message, resource] of [
+          ['exhaust_map', 'Map maximum size exceeded', 'memory'],
+          ['exhaust_set', 'Set maximum size exceeded', 'memory'],
+          ['exhaust_stack', 'Maximum call stack size exceeded', 'stack'],
         ]) {
           const registry = new BuiltinRegistry();
           registry.add(predicate, 0, function* () {
@@ -1099,10 +1100,55 @@ answer(ok) :-
             caught = error;
           }
           assertEqual(caught?.name, 'PrologError', `${predicate} normalized error type`);
-          assertEqual(caught?.formal, 'resource_error(memory)', `${predicate} normalized resource error`);
+          assertEqual(caught?.formal, `resource_error(${resource})`, `${predicate} normalized resource error`);
         }
       },
     },
+    {
+      name: 'unrelated host RangeErrors retain their identity',
+      run: () => {
+        const original = new RangeError('unrelated host failure');
+        const registry = new BuiltinRegistry();
+        registry.add('host_failure', 0, function* () { throw original; });
+        const solver = new Solver(Program.parse(''), { registry });
+        let caught;
+        try {
+          [...solver.solve([parseGoalText('host_failure')], new Env(), 0)];
+        } catch (error) {
+          caught = error;
+        }
+        assertEqual(caught, original, 'unrecognized host error');
+      },
+    },
+    {
+      name: 'nested catch succeeds on cold and warm runs with a small host stack (issue #117)',
+      run: () => {
+        const engineUrl = new URL('../src/index.js', testDirUrl).href;
+        const script = `
+          import { Program, Solver, Env, parseGoalText, getEyePrologRegistry } from ${JSON.stringify(engineUrl)};
+          const program = Program.parse('deep(0,G) :- !, G. deep(N,G) :- M is N-1, catch(deep(M,G),-,true).');
+          const solver = new Solver(program, { registry: getEyePrologRegistry() });
+          const solve = (text) => [...solver.solve([parseGoalText(text)], new Env(), 0)];
+          for (let attempt = 0; attempt < 3; attempt++) {
+            for (const depth of [550, 1500]) {
+              if (solve('deep(' + depth + ',true)').length !== 1) {
+                throw new Error('nested catch failed');
+              }
+              if (solve('catch(deep(' + depth + ',throw(ball)),ball,true)').length !== 1) {
+                throw new Error('nested catch did not unwind to the matching handler');
+              }
+            }
+          }
+          process.stdout.write('passed');
+        `;
+        const result = spawnSync(process.execPath, [
+          '--stack-size=256', '--input-type=module', '--eval', script,
+        ], { cwd: packageRoot, encoding: 'utf8', timeout: 10000 });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, `issue #117 child status; stderr=${result.stderr}`);
+        assertEqual(result.stdout, 'passed', 'issue #117 repeated deep catch execution');
+      },
+    },
     {
       name: 'unbounded length/2 reaches a catchable memory resource error (issue #49)',
       run: () => {

package/test/regression/cases-regression.mjs

@@ -37,6 +37,19 @@ import {
 
 export function regressionCases() {
   return [
+    {
+      name: 'REPL repeated nested catch succeeds from the first query (issue #117)',
+      run: () => {
+        const file = path.join(temp.dir, 'deep-catch-117.pl');
+        fs.writeFileSync(file, 'deep(0,G) :- !, G.\ndeep(N,G) :- M is N-1, catch(deep(M,G),-,true).\n');
+        const result = runCli([], { input:
+          `[${sourceAtom(file)}].\ndeep(550,true).\ndeep(550,true).\ndeep(550,true).\nhalt.\n`,
+        });
+        assertEqual(result.status, 0, result.stderr);
+        assertNotIncludes(result.stdout + result.stderr, 'error(', 'all repeated queries succeed');
+        assertEqual((result.stdout.match(/\btrue\./g) ?? []).length, 4, 'consult and three successful queries');
+      },
+    },
     {
       name: 'close/1 accepts a $stream/1 term rebuilt via functor/3 and arg/3 that is structurally == to the real handle (issue #109)',
       run: () => {