eyeprolog 1.5.101 → 1.5.103

package/package.json

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

package/src/iso.js

@@ -674,10 +674,21 @@ function* termVariablesBuiltin({ goal, env }) {
 }
 
 function validPredicateIndicator(term) {
-  return term.type === COMPOUND && term.name === '/' && term.arity === 2 &&
-    (term.args[0].type === VAR || term.args[0].type === ATOM) &&
-    (term.args[1].type === VAR ||
-      (term.args[1].type === NUMBER && isDecimalInteger(term.args[1].name) && BigInt(term.args[1].name) >= 0n));
+  if (term.type !== COMPOUND || term.name !== '/' || term.arity !== 2) return false;
+  const [name, arity] = term.args;
+  // Name/Arity denotes a predicate indicator only when some instance of it
+  // could be one: Name an atom, Arity a non-negative integer. The same
+  // shared variable in both positions (current_predicate(X/X), issue #115)
+  // looks valid argument-by-argument -- each position individually accepts
+  // an unbound variable -- but no instantiation can satisfy both at once,
+  // since binding that one variable to an atom makes Arity an atom too, not
+  // an integer. stc#79 treats this as no valid instance existing at all,
+  // the same as a bare atom argument, so it must raise
+  // type_error(predicate_indicator, _) rather than just finding no matches.
+  if (name.type === VAR && arity.type === VAR && name.name === arity.name) return false;
+  return (name.type === VAR || name.type === ATOM) &&
+    (arity.type === VAR ||
+      (arity.type === NUMBER && isDecimalInteger(arity.name) && BigInt(arity.name) >= 0n));
 }
 
 const currentPredicateBuiltin = pendingBuiltin(currentPredicateSolutions);

package/src/parser.js

@@ -203,6 +203,21 @@ const CLPZ_OPERATOR_DEFINITIONS = [
   [450, 'xfx', '..'],
 ];
 
+// Names of bundled library(Name) modules whose own operators are pre-seeded
+// into the live parser's operator table the moment `:- use_module(library(
+// Name))` is parsed (applyImportedLibraryOperators below), rather than only
+// once that module's own `:- op(...)` directives are themselves parsed. A
+// library's clauses are parsed and processed in one pass (see
+// loadSourceIntoBuilder in program.js), so without this a file that both
+// imports one of these libraries and uses its custom operator syntax later
+// in the very same source text would fail to parse. Any bundled library
+// whose own source declares `:- op(...)` must be listed here, or it cannot
+// safely be served from the prepared-clause cache in program.js: a cache
+// hit replays already-parsed clause objects directly and never re-runs a
+// live Parser over that library's text, so a cached op/3 directive from an
+// unlisted library would never reach a live parser's operator table.
+export const PRESEEDED_LIBRARY_OPERATOR_NAMES = new Set(['clpz', 'atts', 'tabling', 'debug']);
+
 function operatorStrength(priority) {
   return 1201 - priority;
 }
@@ -421,6 +436,7 @@ class Parser {
     const designation = directive.args[0];
     if (designation?.type !== COMPOUND || designation.name !== 'library' || designation.arity !== 1 ||
         designation.args[0]?.type !== ATOM) return;
+    if (!PRESEEDED_LIBRARY_OPERATOR_NAMES.has(designation.args[0].name)) return;
     if (designation.args[0].name === 'clpz') {
       for (const [priority, specifier, name] of CLPZ_OPERATOR_DEFINITIONS) {
         this.defineOperator(priority, specifier, name);

package/src/program.js

@@ -6,6 +6,7 @@ import {
   ISO_OPERATOR_DEFINITIONS,
   PART2_OPERATOR_DEFINITIONS,
   PART3_OPERATOR_DEFINITIONS,
+  PRESEEDED_LIBRARY_OPERATOR_NAMES,
   QUAD_OPERATOR_DEFINITIONS,
   createParserOperatorState,
   parseClauses,
@@ -108,9 +109,43 @@ function hasDirectCutTailRecursion(group) {
   return sawRecursive;
 }
 
+// library(clpz) alone pulls in about a dozen further bundled libraries
+// (assoc, pairs, between, lists, atts, iso_ext, dcgs, terms, error, si,
+// freeze, arithmetic, debug, format) via its own use_module/1-2 directives,
+// each recursively loaded and prepared (parsed, DCG- and goal-expanded,
+// dependency-analyzed) from scratch on every single program that needs
+// clpz. Matching against every bundled filename, not just clpz.pl's own,
+// lets each of those dependencies -- and every other bundled library used
+// this way -- be prepared once per process and reused, the same as clpz.pl
+// itself already was.
+//
+// A cache hit replays already-prepared clause objects directly (see below)
+// and never re-runs a live Parser over that library's own source text. A
+// library whose own source declares `:- op(...)` relies on exactly that
+// live parse to install its operators into the importing file's operator
+// table before the rest of that file is parsed (loadSourceIntoBuilder
+// processes one whole source's clauses only after fully parsing it), so
+// serving such a library from this cache would silently stop a sibling
+// source term, later in the very same file as its use_module/1 directive,
+// from parsing with that library's operator syntax. Only a library the
+// parser separately pre-seeds regardless of caching
+// (PRESEEDED_LIBRARY_OPERATOR_NAMES) is safe to include despite declaring
+// its own operators.
+const OWN_OPERATOR_DIRECTIVE = /:-(?:\s|\/\*[\s\S]*?\*\/)*op\s*\(/;
+const bundledLibraryFilenames = new Set(
+  Array.from(standardLibrarySources.entries())
+    .filter(([name, entry]) => PRESEEDED_LIBRARY_OPERATOR_NAMES.has(name) || !OWN_OPERATOR_DIRECTIVE.test(entry.source))
+    .map(([, entry]) => entry.filename),
+);
+
 function preparedBundledLibraryCacheKey(program, options) {
   const filename = String(options.filename ?? '');
-  if (filename !== standardLibrarySources.get('clpz')?.filename) return null;
+  if (!bundledLibraryFilenames.has(filename)) return null;
+  // Strict ISO Part 1 skips the normal-profile clause preparation
+  // (expandClauseGoals, normalizeQualifiedClauseHead, DCG expansion) that
+  // this cache stores the result of, so a strict-mode load must never be
+  // served from -- or poison -- a normal-mode cache entry for the same file.
+  if (program.strictIso) return null;
   // A user hook deliberately defined before use_module/1 is allowed to
   // transform bundled source. Such a program needs its own ordinary expansion.
   if (program.groups.has(modulePredicateKey('user', 'term_expansion', 2)) ||

package/test/run-iso-strict.mjs

@@ -1541,6 +1541,11 @@ export function runIsoStrict(reporter = new TestReporter()) {
       ['clause(X,_)', 'instantiation_error', 'clause/2 variable head'],
       ['clause(4,_)', 'type_error(callable)', 'clause/2 head type'],
       ['current_predicate(4)', 'type_error(predicate_indicator)', 'current_predicate/1 indicator type'],
+      // The same variable filling both Name and Arity (issue #115, stc#79)
+      // looks valid position-by-position -- each alone accepts an unbound
+      // variable -- but no instantiation can satisfy both at once, since
+      // binding it to an atom makes Arity an atom too, not an integer.
+      ['current_predicate(X/X)', 'type_error(predicate_indicator)', 'current_predicate/1 aliased name/arity variable'],
       ['asserta(_)', 'instantiation_error', 'asserta/1 variable head'],
       ['asserta(4)', 'type_error(callable)', 'asserta/1 head type'],
       ['asserta((p:-4))', 'type_error(callable)', 'asserta/1 body conversion'],