eyeprolog 1.5.73 → 1.5.76

package/package.json

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

package/src/iso.js

@@ -1153,24 +1153,32 @@ 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);
+  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/src/repl.js

@@ -773,6 +773,18 @@ function formatAnswer(engine, state, variables, env) {
     doubleBar: !state.strictIso,
   };
   let generated = 0;
+  // Names generated for otherwise-anonymous variables (`_A`, `_B`, ...) must
+  // never collide with a name the query itself is already using for a
+  // *different* variable (e.g. a query literally naming `_A`) — printing an
+  // internal fresh variable as `_A` right next to the user's own `_A` binding
+  // falsely suggests they are the same variable (issue #108).
+  const usedDisplayNames = new Set(names.values());
+  const nextGeneratedName = () => {
+    let candidate;
+    do { candidate = `_${letterName(generated++)}`; } while (usedDisplayNames.has(candidate));
+    usedDisplayNames.add(candidate);
+    return candidate;
+  };
 
   // Meta-predicate wrappers can make a query variable alias an internal fresh
   // variable. Keep residual constraints tied to the query's visible name.
@@ -780,7 +792,7 @@ function formatAnswer(engine, state, variables, env) {
     const root = engine.deref(variable, env);
     if (root.type === 'var' && !names.has(root.name)) names.set(root.name, variable.name);
   }
-  for (const variable of variables) collectUnboundVariables(engine, variable, env, names, () => `_${letterName(generated++)}`);
+  for (const variable of variables) collectUnboundVariables(engine, variable, env, names, nextGeneratedName);
   for (const variable of variables) {
     const value = engine.deref(variable, env);
     if (value.type === 'var' &&
@@ -796,7 +808,7 @@ function formatAnswer(engine, state, variables, env) {
   for (const constraint of env.variableConstraints?.() ?? []) {
     const residual = constraint.residualGoal?.(env);
     if (residual == null) continue;
-    collectUnboundVariables(engine, residual, env, names, () => `_${letterName(generated++)}`);
+    collectUnboundVariables(engine, residual, env, names, nextGeneratedName);
     bindings.push(engine.formatTermForWrite(residual, env, answerWriteOptions));
   }
   // Residual attributes are part of the answer even when the attributed
@@ -821,9 +833,9 @@ function formatAnswer(engine, state, variables, env) {
   for (const root of attributeRoots) {
     if (projectedAttributeRoots.has(root.name) || !env.hasPrologAttributes?.(root.name)) continue;
     projectedAttributeRoots.add(root.name);
-    if (!names.has(root.name)) names.set(root.name, `_${letterName(generated++)}`);
+    if (!names.has(root.name)) names.set(root.name, nextGeneratedName());
     for (const residual of state.solver.attributeResidualGoals(root, env)) {
-      collectUnboundVariables(engine, residual, env, names, () => `_${letterName(generated++)}`);
+      collectUnboundVariables(engine, residual, env, names, nextGeneratedName);
       bindings.push(engine.formatTermForWrite(residual, env, answerWriteOptions));
     }
   }

package/test/regression/cases-regression.mjs

@@ -28,6 +28,36 @@ 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: 'top level never mints a generated variable name that collides with a query variable\'s own name (issue #108)',
+      run: () => {
+        const result = runCli([], { input: 'length(L,1),_A=99.\nhalt.\n' });
+        assertEqual(result.status, 0, result.stderr);
+        // `_A` is a real query variable here, not the top level's own first
+        // generated name. Printing the anonymous variable inside L as `_A` as
+        // well would misleadingly suggest it is the same variable as the
+        // query's own `_A`, which is bound to 99 and unrelated to L.
+        assertIncludes(result.stdout, '?-    L = [_B], _A = 99.\n', 'generated name skips the query\'s own _A');
+      },
+    },
     {
       name: 'REPL current_input/1 and current_output/1 fail on closed stream handles (issue #107)',
       run: () => {