eyeprolog 1.5.75 → 1.5.77

package/package.json

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

package/src/iso.js

@@ -1153,24 +1153,38 @@ function streamHandle(id) {
   return compound('$stream', [numberTerm(id)]);
 }
 
+function streamHandleId(value, env) {
+  // A `$stream(Id)` term is an ordinary compound, not an opaque blob, so
+  // general term-construction predicates such as functor/3 and arg/3 can
+  // rebuild one whose argument is a variable that only later gets unified
+  // with the real stream number (issue #109). Deref that argument, the same
+  // as any other compound argument, instead of inspecting the raw arg term
+  // and rejecting an equally valid stream reference as malformed.
+  if (value.type !== COMPOUND || value.name !== '$stream' || value.arity !== 1) return null;
+  const id = deref(value.args[0], env);
+  // The shape is right, but the argument that would identify the stream is
+  // still unbound: whether this term is a valid stream reference cannot be
+  // decided yet, so that is an instantiation error, not a domain error (see
+  // issue #109's stc#72 follow-up) — unlike a wrong functor/arity above,
+  // which can never become valid no matter how any variable gets bound.
+  if (id.type === VAR) throw new PrologError('instantiation_error');
+  return id.type === NUMBER && isDecimalInteger(id.name) ? Number(id.name) : null;
+}
+
 function streamReference(term, env) {
   const value = deref(term, env);
   if (value.type === VAR) throw new PrologError('instantiation_error');
   if (value.type === ATOM) return value.name;
-  if (value.type === COMPOUND && value.name === '$stream' && value.arity === 1 &&
-      value.args[0].type === NUMBER && isDecimalInteger(value.args[0].name)) {
-    return Number(value.args[0].name);
-  }
+  const id = streamHandleId(value, env);
+  if (id != null) return id;
   throw new PrologError('domain_error(stream_or_alias)', value);
 }
 
 function streamTermReference(term, env) {
   const value = deref(term, env);
   if (value.type === VAR) return null;
-  if (value.type === COMPOUND && value.name === '$stream' && value.arity === 1 &&
-      value.args[0].type === NUMBER && isDecimalInteger(value.args[0].name)) {
-    return Number(value.args[0].name);
-  }
+  const id = streamHandleId(value, env);
+  if (id != null) return id;
   throw new PrologError('domain_error(stream)', value);
 }
 

package/test/regression/cases-regression.mjs

@@ -28,6 +28,39 @@ import {
 
 export function regressionCases() {
   return [
+    {
+      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: () => {
+        const file = sourceAtom(path.join(temp.dir, `stream-109-${++temp.counter}.txt`));
+        const result = runCli([], { input:
+          `open(${file},write,S),functor(S,Fn,A),functor(S2,Fn,A),arg(1,S,A1),arg(1,S2,A1),S==S2,close(S2).\n` +
+          'halt.\n',
+        });
+        assertEqual(result.status, 0, result.stderr);
+        // S2's argument only becomes the real stream number through
+        // unification rather than being built in place by open/3, so
+        // close/1 must deref it like any other compound argument instead of
+        // rejecting an equally valid, structurally-== stream reference as
+        // malformed.
+        assertNotIncludes(result.stdout + result.stderr, 'error(', 'no domain_error(stream_or_alias, ...) from close/1');
+        assertIncludes(result.stdout, 'A1 = ', 'query succeeds and reports the shared stream number');
+      },
+    },
+    {
+      name: 'close/1 raises instantiation_error, not domain_error(stream_or_alias), for a $stream/1 term whose argument is unbound (issue #109 follow-up)',
+      run: () => {
+        const result = runCli([], { input:
+          "S='$stream'(X),close(S).\nhalt.\n",
+        });
+        assertEqual(result.status, 0, result.stderr);
+        // The argument that would identify the stream is still unbound, so
+        // whether this term is a valid stream reference cannot be decided
+        // yet — that calls for instantiation_error, not a domain_error
+        // claiming the term itself is already known to be invalid.
+        assertIncludes(result.stdout, 'error(instantiation_error,', 'unbound $stream/1 argument reports instantiation_error');
+        assertNotIncludes(result.stdout, 'domain_error(stream_or_alias', 'no domain_error(stream_or_alias, ...) once the argument is still unbound');
+      },
+    },
     {
       name: 'top level never mints a generated variable name that collides with a query variable\'s own name (issue #108)',
       run: () => {