eyeprolog 1.2.26 → 1.2.27

package/package.json

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

package/src/iso.js

@@ -1144,6 +1144,43 @@ function convertedTermText(text, solver) {
   }
   return result;
 }
+
+function scopeReadTerm(term) {
+  // A term read from a stream has its own variable set (ISO 7.10.3).  Parser
+  // variable names cannot be used as environment identities here: a caller
+  // such as read(X) and an input term X=a would otherwise share the same `X`
+  // and incorrectly attempt the cyclic unification X=(X=a).  Use an internal
+  // name containing NUL, which cannot occur in Prolog source, while retaining
+  // the spelling and occurrence count required by read_term/3 metadata.
+  const scope = ++isoFresh;
+  const bySourceName = new Map();
+  const variables = [];
+
+  const copy = (item) => {
+    if (item.type === VAR) {
+      let record = bySourceName.get(item.name);
+      if (record == null) {
+        const scoped = variable(`\u0000read:${scope}:${variables.length}`);
+        scoped.displayName = item.name;
+        record = {
+          sourceName: item.name,
+          term: scoped,
+          count: 0,
+          anonymous: item.name.startsWith('__anon'),
+        };
+        bySourceName.set(item.name, record);
+        variables.push(record);
+      }
+      record.count++;
+      return record.term;
+    }
+    if (item.type !== COMPOUND) return item;
+    return compound(item.name, item.args.map(copy));
+  };
+
+  return { term: copy(term), variables };
+}
+
 function readTermFromStream(stream, solver) {
   let requestedInteractiveTerm = false;
   while (true) {
@@ -1164,7 +1201,7 @@ function readTermFromStream(stream, solver) {
         });
         if (clauses.length !== 1 || clauses[0].body.length) throw new Error('bad term');
         stream.position = candidate.end;
-        return clauses[0].head;
+        return scopeReadTerm(clauses[0].head);
       } catch (_) {
         // A dot inside a graphic operator, such as =.., is only a possible
         // terminator. Keep scanning until a complete term parses.
@@ -1192,7 +1229,7 @@ function readTermFromStream(stream, solver) {
     stream.position = source.length;
     if (!sawCandidate) {
       if (hasNonLayoutRemainder(source, remainderStart)) throw new PrologError('syntax_error(read_term)');
-      return atom('end_of_file');
+      return { term: atom('end_of_file'), variables: [] };
     }
     throw new PrologError('syntax_error(read_term)');
   }
@@ -1202,39 +1239,31 @@ function* readBuiltin({ solver, goal, env }) {
   const stream = inputStreamFor(solver, goal, env);
   if (stream.type !== 'text') throw new PrologError('permission_error(input, binary_stream)', streamHandle(stream.id));
   const next = env.clone();
-  if (unify(goal.args[goal.arity - 1], readTermFromStream(stream, solver), next)) yield next;
+  const { term } = readTermFromStream(stream, solver);
+  if (unify(goal.args[goal.arity - 1], term, next)) yield next;
 }
 function* readTermBuiltin({ solver, goal, env }) {
   const stream = goal.arity === 2 ? solver.io.resolve(solver.io.currentInput) : requireStream(solver, goal.args[0], env, 'read');
   if (stream.type !== 'text') throw new PrologError('permission_error(input, binary_stream)', streamHandle(stream.id));
   const options = optionList(goal.args[goal.arity - 1], env);
   const target = goal.args[goal.arity - 2];
-  const term = readTermFromStream(stream, solver);
+  const { term, variables } = readTermFromStream(stream, solver);
   const next = env.clone();
   if (!unify(target, term, next)) return;
-  const variables = [];
-  const counts = new Map();
-  const visit = (item) => {
-    if (item.type === VAR) {
-      counts.set(item.name, (counts.get(item.name) ?? 0) + 1);
-      if (!variables.some((entry) => entry.name === item.name)) variables.push(item);
-    } else for (const arg of item.args) visit(arg);
-  };
-  visit(term);
   for (const option of options) {
     if (option.type === VAR) throw new PrologError('instantiation_error');
     if (option.type !== COMPOUND || option.arity !== 1) throw new PrologError('domain_error(read_option)', option);
     let value;
     if (option.name === 'variables') {
-      value = listFromItems(variables);
+      value = listFromItems(variables.map((item) => item.term));
     } else if (option.name === 'variable_names') {
       value = listFromItems(variables
-        .filter((item) => !item.name.startsWith('__anon'))
-        .map((item) => compound('=', [atom(item.name), item])));
+        .filter((item) => !item.anonymous)
+        .map((item) => compound('=', [atom(item.sourceName), item.term])));
     } else if (option.name === 'singletons') {
       value = listFromItems(variables
-        .filter((item) => !item.name.startsWith('__anon') && counts.get(item.name) === 1)
-        .map((item) => compound('=', [atom(item.name), item])));
+        .filter((item) => !item.anonymous && item.count === 1)
+        .map((item) => compound('=', [atom(item.sourceName), item.term])));
     } else {
       throw new PrologError('domain_error(read_option)', option);
     }

package/src/term.js

@@ -413,9 +413,26 @@ function writeList(term, env, options) {
 }
 
 export function termToString(term, env = new Env(), quoteStrings = true, options = {}) {
-  options = { doubleQuotes: options.doubleQuotes ?? 'chars' };
+  options = {
+    ...options,
+    doubleQuotes: options.doubleQuotes ?? 'chars',
+    readVariableNames: options.readVariableNames instanceof Map ? options.readVariableNames : new Map(),
+    usedReadVariableNames: options.usedReadVariableNames instanceof Set ? options.usedReadVariableNames : new Set(),
+  };
   const resolved = deref(term, env);
-  if (resolved.type === VAR) return writeVariable(resolved.name);
+  if (resolved.type === VAR) {
+    if (resolved.displayName == null) return writeVariable(resolved.name);
+    let printed = options.readVariableNames.get(resolved.name);
+    if (printed == null) {
+      const base = writeVariable(resolved.displayName);
+      printed = base;
+      let suffix = 1;
+      while (options.usedReadVariableNames.has(printed)) printed = `${base}_${suffix++}`;
+      options.readVariableNames.set(resolved.name, printed);
+      options.usedReadVariableNames.add(printed);
+    }
+    return printed;
+  }
   if (isCons(resolved)) return writeList(resolved, env, options);
   if (resolved.type === STRING) return writeString(resolved.name, quoteStrings);
   if (resolved.type === ATOM) return writeAtom(resolved.name);

package/src/write.js

@@ -134,9 +134,42 @@ function chooseOperator(term, table) {
   return null;
 }
 
+function printableReadVariableNames(term, env, explicit) {
+  const names = new Map(explicit);
+  const used = new Set(names.values());
+  const suffixes = new Map();
+  const seenVariables = new Set();
+  const seenTerms = new Set();
+  const stack = [term];
+
+  while (stack.length) {
+    const current = deref(stack.pop(), env);
+    if (current.type === VAR) {
+      if (seenVariables.has(current.name)) continue;
+      seenVariables.add(current.name);
+      if (names.has(current.name) || current.displayName == null) continue;
+      const base = writeVariable(current.displayName);
+      let candidate = base;
+      let suffix = suffixes.get(base) ?? 1;
+      while (used.has(candidate)) candidate = `${base}_${suffix++}`;
+      suffixes.set(base, suffix);
+      names.set(current.name, candidate);
+      used.add(candidate);
+      continue;
+    }
+    if (current.type !== COMPOUND || seenTerms.has(current)) continue;
+    seenTerms.add(current);
+    for (let i = current.arity - 1; i >= 0; i--) stack.push(current.args[i]);
+  }
+
+  return names;
+}
+
 function format(term, env, options, table, maxPriority = 1200, context = 'term') {
   const resolved = deref(term, env);
-  if (resolved.type === VAR) return options.variableNames.get(resolved.name) ?? writeVariable(resolved.name);
+  if (resolved.type === VAR) {
+    return options.variableNames.get(resolved.name) ?? writeVariable(resolved.displayName ?? resolved.name);
+  }
   if (resolved.type === STRING) return writeString(resolved.name);
   if (resolved.type === ATOM) {
     if (!options.quoted) return resolved.name;
@@ -224,12 +257,13 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
 }
 
 export function formatTermForWrite(term, env = new Env(), options = {}) {
+  const explicitVariableNames = options.variableNames instanceof Map ? options.variableNames : new Map();
   const normalized = {
     quoted: options.quoted === true,
     ignoreOps: options.ignoreOps === true,
     numbervars: options.numbervars !== false,
     doubleQuotes: options.doubleQuotes,
-    variableNames: options.variableNames instanceof Map ? options.variableNames : new Map(),
+    variableNames: printableReadVariableNames(term, env, explicitVariableNames),
     compact: options.compact === true,
     operatorAtomsAsArgs: options.operatorAtomsAsArgs === true,
   };

package/test/run-regression.mjs

@@ -1284,6 +1284,35 @@ c4 ?- call((!;1)).
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'read terms have a variable scope distinct from the calling query',
+      run: () => {
+        const result = runCli([], {
+          input:
+            'read(X).\n' +
+            'X=a.\n' +
+            'read(X).\n' +
+            'Y=a.\n' +
+            'read_term(X, [variables(Vs), variable_names(Names), singletons(Singletons)]).\n' +
+            'X = pair(X, Y).\n' +
+            'halt.\n',
+        });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout,
+          '?-   |:  X = (_A = a).\n' +
+          '?-   |:  X = (_A = a).\n' +
+          "?-   |:  X = (_A = pair(_A, _B)), Vs = [_A, _B], Names = ['X' = _A, 'Y' = _B], Singletons = ['Y' = _B].\n" +
+          '?- ',
+          'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+
+        const distinctReads = run(
+          'check :- read(A), read(B), A \\== B, write_canonical(pair(A, B)), nl.\n',
+          { goal: 'check', ioOptions: { input: 'V.\nV.\n' } },
+        );
+        assertEqual(distinctReads.stdout, 'pair(V,V_1)\ncheck.\n', 'separate read variable sets');
+      },
+    },
     {
       name: 'REPL term input is on demand in conjunctions and Ctrl-D does not exit the top level',
       run: () => {