eyeprolog 1.5.69 → 1.5.71

package/package.json

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

package/src/iso.js

@@ -1345,9 +1345,9 @@ function* currentInputBuiltin({ solver, goal, env }) {
   const value = deref(goal.args[0], env);
   if (value.type !== VAR) {
     const id = streamTermReference(goal.args[0], env);
-    const stream = solver.io.resolve(id);
-    if (!stream) throw new PrologError('domain_error(stream)', value);
-    if (stream.id === solver.io.currentInput) yield env;
+    // A closed handle is still a stream-term, but cannot be current (#107).
+    // Validate its shape, then test identity rather than requiring an open stream.
+    if (id === solver.io.currentInput) yield env;
     return;
   }
   const next = env.clone();
@@ -1357,9 +1357,7 @@ function* currentOutputBuiltin({ solver, goal, env }) {
   const value = deref(goal.args[0], env);
   if (value.type !== VAR) {
     const id = streamTermReference(goal.args[0], env);
-    const stream = solver.io.resolve(id);
-    if (!stream) throw new PrologError('domain_error(stream)', value);
-    if (stream.id === solver.io.currentOutput) yield env;
+    if (id === solver.io.currentOutput) yield env;
     return;
   }
   const next = env.clone();

package/src/lib/error.pl

@@ -55,6 +55,7 @@ error__must_be(acyclic, Term) :- !,
 error__must_be(list, Term) :- !,
     error__list(Term, Term, must_be/2, complete).
 error__must_be(list(Type), Term) :- !,
+    error__require_type(Type, must_be/2),
     error__list(Term, Term, must_be/2, complete),
     error__proper_list_of(Term, Type).
 error__must_be(character, Term) :- !,
@@ -75,10 +76,30 @@ error__must_be(pair, Term) :- !,
 error__must_be(not_less_than_zero, Term) :- !,
     must_be(integer, Term),
     ( Term >= 0 -> true ; domain_error(not_less_than_zero, Term) ).
-error__must_be(Type, Term) :-
-    ( var(Term) -> error__must_be_throw(instantiation_error)
-    ; error__must_be_throw(type_error(Type, Term))
-    ).
+error__must_be(Type, _) :-
+    error__must_be_throw(type_error(type, Type)).
+
+% Check the type descriptor before accepting a variable or an empty list.
+% The variable guard also prevents validation from instantiating a descriptor.
+error__require_type(Type, Predicate) :- var(Type), !,
+    throw(error(instantiation_error, [predicate-Predicate])).
+error__require_type(list(Type), Predicate) :- !,
+    error__require_type(Type, Predicate).
+error__require_type(Type, Predicate) :-
+    ( error__known_type(Type) -> true
+    ; throw(error(type_error(type, Type), [predicate-Predicate])) ).
+
+error__known_type(integer).
+error__known_type(atom).
+error__known_type(number).
+error__known_type(var).
+error__known_type(ground).
+error__known_type(acyclic).
+error__known_type(list).
+error__known_type(character).
+error__known_type(chars).
+error__known_type(pair).
+error__known_type(not_less_than_zero).
 
 % A list ends in []; a partial list ends in a variable (including a variable
 % alone). Inspect before matching so validation never completes a partial list.
@@ -102,8 +123,8 @@ error__proper_list_of(Term, _) :-
     ).
 
 can_be(Type, Term) :-
-    ( var(Type) -> error__can_be_throw(instantiation_error)
-    ; var(Term) -> true
+    error__require_type(Type, can_be/2),
+    ( var(Term) -> true
     ; error__can_be(Type, Term)
     ).
 

package/src/solver.js

@@ -838,6 +838,16 @@ export class Solver {
           continue;
         }
 
+        const appendIterator = bundledAppendIterator(this, group, goal, env);
+        if (appendIterator != null) {
+          const firstResult = appendIterator.next();
+          if (firstResult.done) break;
+          goals = rest;
+          env = firstResult.value;
+          depth++;
+          continue;
+        }
+
         const comparisonIterator = bundledCompareSiIterator(this, group, goal, env);
         if (comparisonIterator != null) {
           const firstResult = comparisonIterator.next();
@@ -1896,6 +1906,44 @@ function* bundledBetweenSolutions(solver, goal, env, state) {
   state.pending = false;
 }
 
+function bundledAppendIterator(solver, group, goal, env) {
+  if (solver.registry.eyePrologLibrary !== true || group.bundledLibrary !== true ||
+      group.module !== 'lists' || group.name !== 'append' || group.arity !== 3 ||
+      group.tabled || group.clauses.length !== 2) return null;
+  // Preserve source-defined hook ordering and occurs-check diagnostics. Only
+  // forward construction with a plain, unbound result is specialized.
+  if (env._prologAttributes != null || env._delays != null ||
+      solver.prologFlags.get('occurs_check')?.value?.name === 'error' ||
+      deref(goal.args[2], env).type !== VAR) return null;
+
+  const items = [];
+  const seen = new Set();
+  let cursor = deref(goal.args[0], env);
+  while (isCons(cursor)) {
+    if (seen.has(cursor)) return null;
+    seen.add(cursor);
+    items.push(cursor.args[0]);
+    if ((items.length & 255) === 0) solver.checkMemoryLimit(true);
+    cursor = deref(cursor.args[1], env);
+  }
+  if (!isEmptyList(cursor)) return null;
+  return bundledAppendSolutions(solver, goal, env, items);
+}
+
+function* bundledAppendSolutions(solver, goal, env, items) {
+  // Copy just the prefix spine, preserving its variables and sharing the
+  // suffix. One normal, occurs-checked unification replaces repeated clause
+  // freshening and scans over every remaining variable-list suffix.
+  let joined = goal.args[1];
+  for (let i = items.length - 1; i >= 0; i--) {
+    joined = cons(items[i], joined);
+    if ((i & 255) === 0) solver.checkMemoryLimit(true);
+  }
+  const next = env.clone();
+  solver.stats.unify_calls++;
+  if (unify(goal.args[2], joined, next)) yield next;
+}
+
 function bundledMemberIterator(solver, group, goal, env) {
   if (solver.registry.eyePrologLibrary !== true ||
       group.module !== 'lists' || group.name !== 'member' || group.arity !== 2 ||

package/test/regression/cases-regression.mjs

@@ -28,6 +28,102 @@ import {
 
 export function regressionCases() {
   return [
+    {
+      name: 'REPL current_input/1 and current_output/1 fail on closed stream handles (issue #107)',
+      run: () => {
+        const file = sourceAtom(path.join(temp.dir, 'closed-stream-107.txt'));
+        const result = runCli([], { input:
+          `open(${file},write,S),close(S),current_input(S).\n` +
+          `open(${file},write,S),close(S),current_output(S).\nhalt.\n`,
+        });
+        assertEqual(result.status, 0, result.stderr);
+        assertEqual((result.stdout.match(/false\./g) ?? []).length, 2, 'both closed-handle queries fail');
+        assertNotIncludes(result.stdout + result.stderr, 'error(', 'no stream domain error');
+      },
+    },
+    {
+      name: 'must_be/2 and can_be/2 reject invalid type descriptors before checking values (issue #106)',
+      run: () => {
+        for (const predicate of ['must_be', 'can_be']) {
+          for (const type of ['nontype', '42', 'foo(integer)', 'list(nontype)', 'list(list(nontype))']) {
+            const culprit = type.startsWith('list(') ? 'nontype' : type;
+            for (const value of ['0', 'X', '[]']) {
+              const result = runEyeProlog(`answer(ok) :- catch((${predicate}(${type},${value}),fail),error(type_error(type,${culprit}),[predicate-${predicate}/2]),true),var(X).`, { goals: ['answer(X)'] });
+              assertIncludes(result.stdout, 'answer(ok)', `${predicate}(${type},${value})`);
+            }
+          }
+          for (const type of ['T', 'list(T)', 'list(list(T))']) {
+            const result = runEyeProlog(`answer(ok) :- catch((${predicate}(${type},[]),fail),error(instantiation_error,[predicate-${predicate}/2]),true),var(T).`, { goals: ['answer(X)'] });
+            assertIncludes(result.stdout, 'answer(ok)', `${predicate}(${type},[])`);
+          }
+        }
+        const valid = [
+          ['integer', '1'], ['atom', 'a'], ['number', '1.5'], ['var', 'X'],
+          ['ground', 'f(a)'], ['acyclic', 'f(X)'], ['list', '[X]'],
+          ['character', 'a'], ['chars', '[a,b]'], ['pair', 'a-b'],
+          ['not_less_than_zero', '0'], ['list(integer)', '[1,2]'],
+          ['list(list(integer))', '[[1],[]]'],
+        ];
+        for (const [type, value] of valid) {
+          const result = runEyeProlog(`answer(ok) :- must_be(${type},${value}),can_be(${type},${value}),can_be(${type},Fresh),var(Fresh).`, { goals: ['answer(X)'] });
+          assertIncludes(result.stdout, 'answer(ok)', `supported type ${type}`);
+        }
+        const context = runEyeProlog('answer(ok) :- catch((call_with_error_context(can_be(nontype,X),outer-1),fail),error(type_error(type,nontype),[outer-1,predicate-can_be/2]),true),var(X).', { goals: ['answer(X)'] });
+        assertIncludes(context.stdout, 'answer(ok)', 'composable error context');
+      },
+    },
+    {
+      name: 'forward bundled append/3 matches the portable relation across sharing and fallback modes',
+      run: () => {
+        const goals = [
+          'append([],Y,Z),Y=tail',
+          'append([X,Y],[Y,X],Z),X=a,Y=b',
+          'append([X],T,Z),T=[X|Rest],Rest=tail',
+          'append([a,b],tail,Z)',
+          'append([X],[],X)',
+          'append([a],Z,Z)',
+          'append([X],[],Z),X=Z',
+          'append([a],T,Z),T=Z',
+          'append([a],[],[b])',
+          'append([a|T],[b],[a,c,b])',
+          'append([a|bad],[],Z)',
+          'append(X,Y,[a,b])',
+          '(append([a],[],Z);append([b],[],Z))',
+          'freeze(X,Y=woke),append([X],[],Z),X=a',
+          'dif(X,a),append([X],[],Z),X=b',
+          'set_prolog_flag(occurs_check,error),catch(append([X],[],X),error(E,_),true)',
+        ];
+        for (const goal of goals) {
+          const source = `answer(X,Y,Z,T,Rest,E) :- ${goal}.`;
+          const options = { goals: ['answer(X,Y,Z,T,Rest,E)'] };
+          const optimized = runEyeProlog(source, options);
+          const portable = runEyeProlog(
+            'portable_append([],Ys,Ys). portable_append([X|Xs],Ys,[X|Zs]) :- portable_append(Xs,Ys,Zs).\n' +
+            source.replaceAll('append(', 'portable_append('), options);
+          assertEqual(optimized.stdout, portable.stdout, goal);
+          assertEqual(optimized.stderr, portable.stderr, `${goal} diagnostics`);
+        }
+        const custom = runEyeProlog('append(custom,_,ok).', { goals: ['append(custom,[],Z)'] });
+        assertIncludes(custom.stdout, 'append(custom, [], ok)', 'user definition');
+      },
+    },
+    {
+      name: 'forward append/3 constructs long shared-variable lists within a bounded heap and time',
+      run: () => {
+        const script = `
+          import {run} from './src/index.js';
+          const result=run('answer(ok) :- length(P,8192),append(P,[1],L1),append(P,[2],L2),compare(R,L1,L2),compare_si(S,L1,L2),R==(<),S==(<).', {goals:['answer(X)']});
+          if (!result.stdout.includes('answer(ok)')) throw new Error(result.stdout+'\\n'+result.stderr);
+          console.log('ok');
+        `;
+        const result = spawnSync(process.execPath, ['--max-old-space-size=128', '--stack-size=256', '--input-type=module', '--eval', script], {
+          cwd: packageRoot, encoding: 'utf8', timeout: 10000,
+        });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, result.stderr);
+        assertIncludes(result.stdout, 'ok', 'long forward append');
+      },
+    },
     {
       name: 'autoload follows declared meta-predicates and closure arities (issue #105)',
       run: () => {

package/test/run-iso-strict.mjs

@@ -23,6 +23,35 @@ import { TestReporter, isMainModule, runStandalone } from './test-style.mjs';
 export function runIsoStrict(reporter = new TestReporter()) {
   reporter.section('Strict ISO core');
 
+  reporter.test('current stream queries fail for closed handles while stream operations report existence errors (issue #107)', () => {
+    const directory = mkdtempSync(join(tmpdir(), 'eyeprolog-stream-107-'));
+    const file = `'${join(directory, 'stream.txt').replaceAll("'", "''")}'`;
+    try {
+      writeFileSync(join(directory, 'stream.txt'), '');
+      for (const isoStrict of [false, true]) {
+        for (const predicate of ['current_input', 'current_output']) {
+          equal(run('', { isoStrict, goal: `open(${file},write,S),close(S),${predicate}(S)` }).stdout,
+            '', `${predicate}/1 fails on the reported closed handle`);
+          const mode = predicate === 'current_input' ? 'read' : 'write';
+          const setter = mode === 'read' ? 'set_input' : 'set_output';
+          const source = `answer(ok) :- ${predicate}(Original),open(${file},${mode},S),` +
+            `\\+ ${predicate}(S),${setter}(S),${predicate}(S),close(S),` +
+            `\\+ ${predicate}(S),${predicate}(Original),` +
+            `catch((${setter}(S),fail),error(existence_error(stream,_),_),true),` +
+            'catch((close(S),fail),error(existence_error(stream,_),_),true).';
+          equal(run(source, { isoStrict, goal: 'answer(X)' }).stdout, 'answer(ok).\n',
+            `${predicate}/1 recognizes live handles and restores the standard stream after close`);
+          for (const term of ['foo', '42', "'$stream'(foo)"]) {
+            equal(capture(() => run('', { isoStrict, goal: `${predicate}(${term})` })).formal,
+              'domain_error(stream)', `${predicate}/1 rejects malformed stream term ${term}`);
+          }
+        }
+      }
+    } finally {
+      rmSync(directory, { recursive: true, force: true });
+    }
+  });
+
   reporter.test('executes ordinary Part 1 clauses', () => {
     const result = run('p(X) :- X = 1.\n', { isoStrict: true, goal: 'p(1)' });
     equal(result.stdout, 'p(1).\n', 'stdout');