eyeprolog 1.6.40 → 1.6.41

package/package.json

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

package/src/check-proof.js

@@ -152,8 +152,19 @@ function isAtom(term, name) {
   return term?.type === ATOM && term.name === name;
 }
 
+// While a proof is checked, each term is spelled once: a step's conclusion is
+// also the use of the step that rests on it, and the coverage, relevance and
+// well-foundedness checks each look it up.
+let keyMemo = null;
+
 function key(term) {
-  return termToString(term, new Env(), true);
+  if (keyMemo == null || term === null || typeof term !== 'object') return termToString(term, new Env(), true);
+  let spelled = keyMemo.get(term);
+  if (spelled === undefined) {
+    spelled = termToString(term, new Env(), true);
+    keyMemo.set(term, spelled);
+  }
+  return spelled;
 }
 
 // A term is identical to another when it needs no further instantiation to
@@ -455,7 +466,17 @@ export function checkProofDocument(program, text, options = {}) {
 // its own proofs this way before writing them (SPEC.md, Section 7.1); that the
 // text it writes reads back as the same structures is what checking the
 // packaged documents establishes.
-export function checkProof(program, { claims, records = [], steps: allSteps }, options = {}, failures = []) {
+export function checkProof(program, document, options = {}, failures = []) {
+  const outer = keyMemo;
+  keyMemo ??= new WeakMap();
+  try {
+    return checkProofWithKeys(program, document, options, failures);
+  } finally {
+    keyMemo = outer;
+  }
+}
+
+function checkProofWithKeys(program, { claims, records = [], steps: allSteps }, options, failures) {
   const writeOptions = {
     doubleQuotes: program?.doubleQuotes ?? 'chars', doubleBar: true, quoted: true,
     operators: [...(program?.operators?.values() ?? [])],
@@ -472,7 +493,13 @@ export function checkProof(program, { claims, records = [], steps: allSteps }, o
   for (const record of records) {
     const number = record.args[0]?.type === NUMBER ? Number(record.args[0].name) : NaN;
     const clause = Number.isInteger(number) ? numbering.get(number) : null;
-    if (!clause || !identical(normalizedClauseRecord(record), normalizedClauseRecord(clauseRecordTerm(number, clause)))) {
+    if (!clause) {
+      fail('C1', 'clause record differs from source', record);
+      continue;
+    }
+    // A record that is the rebuilt record itself restates the clause.
+    const rebuilt = clauseRecordTerm(number, clause);
+    if (record !== rebuilt && !identical(normalizedClauseRecord(record), normalizedClauseRecord(rebuilt))) {
       fail('C1', 'clause record differs from source', record);
     }
   }

package/src/explain.js

@@ -1009,6 +1009,7 @@ function resolvedSubstitutions(substitutions, env) {
 // would displace the real clause and every step citing it would stop
 // resolving. Such a declaration is never what a rule(N) or fact(N) cites.
 function isUnnumberedDeclaration(clause) {
+  if (clause?.compactBinary === true) return false;
   const head = clause?.head;
   if (head?.type !== COMPOUND || head.name !== ':-' || head.arity !== 1) return false;
   const directive = head.args[0];
@@ -1016,7 +1017,36 @@ function isUnnumberedDeclaration(clause) {
   return ['module', 'use_module', 'meta_predicate', 'attribute'].includes(directive.name);
 }
 
+// A Map from small positive integers, kept in an array.
+class NumberedTable {
+  constructor() {
+    this.items = [];
+  }
+
+  get(number) {
+    return Number.isInteger(number) && number >= 0 ? this.items[number] : undefined;
+  }
+
+  set(number, value) {
+    this.items[number] = value;
+  }
+}
+
+// A proof is numbered when it is flattened and again when it is checked, and
+// both see the same program; the numbering is kept until the program's
+// clauses change.
+const numberings = new WeakMap();
+
 export function clauseNumbering(program) {
+  const clauses = program.clauses ?? [];
+  const cached = numberings.get(program);
+  if (cached && cached.clauses === clauses && cached.length === clauses.length) return cached.numbering;
+  const numbering = computeClauseNumbering(program);
+  numberings.set(program, { clauses, length: clauses.length, numbering });
+  return numbering;
+}
+
+function computeClauseNumbering(program) {
   const spans = new Map();
   for (const clause of program.clauses ?? []) {
     if (!isProgramClause(clause)) continue;
@@ -1032,17 +1062,19 @@ export function clauseNumbering(program) {
 
   // Keyed by file, then by clause position: one string key per clause cost
   // more than the numbering itself on programs with hundreds of thousands of
-  // clauses.
+  // clauses. Positions and numbers count up from 1, so arrays hold them.
   const bySource = new Map();
-  const byNumber = new Map();
+  const byNumber = new NumberedTable();
   for (const clause of program.clauses ?? []) {
     if (!isProgramClause(clause) || isUnnumberedDeclaration(clause)) continue;
     const { filename, clause: position } = clause.source;
     const number = (offsets.get(filename) ?? 0) + position;
     let numbers = bySource.get(filename);
-    if (!numbers) bySource.set(filename, numbers = new Map());
+    if (!numbers) bySource.set(filename, numbers = new NumberedTable());
     numbers.set(position, number);
-    byNumber.set(number, { head: clause.head, body: clause.body ?? [] });
+    // The clause itself, not a copy of its head and body: a compact clause
+    // builds those terms only when a proof cites it.
+    byNumber.set(number, clause.compactBinary === true || clause.body != null ? clause : { head: clause.head, body: [] });
   }
   return { bySource, byNumber };
 }

package/src/parser.js

@@ -1504,8 +1504,8 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
   let operatorState = null;
   // With source metadata, this path numbers clauses exactly as the general
   // parser does: one number per clause and per counted directive, none for a
-  // query or a quad. Compact binary clauses carry no source, so they are not
-  // used then.
+  // query or a quad. A compact binary clause is numbered the same way, through
+  // the clause object its builder hands back.
   const trackSource = options.sourceMetadata === true;
   const sourceFilename = options.filename ?? '<input>';
   let clauseNumber = 0;
@@ -1774,18 +1774,20 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     if (rule < 0) {
       if (!parseBinaryRawRange(text, start, termEnd, rawHead)) return false;
       reportFastBinarySingletonWarnings(rawHead, null, line);
-      emitBinary(rawHead.name,
+      const clause = emitBinary(rawHead.name,
         rawHead.arg0Type, rawHead.arg0Name, rawHead.arg1Type, rawHead.arg1Name,
         null, null, null, null, null);
+      if (clause) numbered(clause, line);
       return true;
     }
     if (findRuleInRange(text, rule + 2, termEnd) >= 0 ||
         !parseBinaryRawRange(text, start, rule, rawHead) ||
         !parseBinaryRawRange(text, rule + 2, termEnd, rawBody)) return false;
     reportFastBinarySingletonWarnings(rawHead, rawBody, line);
-    emitBinary(rawHead.name,
+    const clause = emitBinary(rawHead.name,
       rawHead.arg0Type, rawHead.arg0Name, rawHead.arg1Type, rawHead.arg1Name,
       rawBody.name, rawBody.arg0Type, rawBody.arg0Name, rawBody.arg1Type, rawBody.arg1Name);
+    if (clause) numbered(clause, line);
     return true;
   };
 
@@ -1851,12 +1853,14 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     // subsequent source character must pass through the full tokenizer. The
     // compact parser deliberately operates on raw source ranges, so using it
     // here would silently bypass Convc for otherwise simple clauses.
+    const anonymousBefore = anonymous;
     const simple = preparationConversionActive() ? null : parseSimple(text);
     if (simple) {
       reportClauseSingletonWarnings(simple, options.onWarning, options.filename ?? '<input>', sourceLine);
       accept(numbered(simple, sourceLine));
       return true;
     }
+    anonymous = anonymousBefore;
     try {
       const nestedWarning = typeof options.onWarning === 'function'
         ? (warning) => options.onWarning({ ...warning, line: warning.line + sourceLine - 1 })
@@ -1912,14 +1916,19 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     contentEnd = trimRangeEnd(source, contentStart, contentEnd);
     if (contentStart < contentEnd && source.charCodeAt(contentStart) !== 37) {
       if (!chunk && source.charCodeAt(contentEnd - 1) === 46 && !preparationConversionActive()) {
-        if (!trackSource && emitFastBinaryRange(source, contentStart, contentEnd, lineNumber)) {
+        // A reader that declines a clause may have named some of its
+        // anonymous variables already; the next one starts the count again.
+        const anonymousBefore = anonymous;
+        if (emitFastBinaryRange(source, contentStart, contentEnd, lineNumber)) {
           // The program builder accepted a compact binary clause directly.
         } else {
+          anonymous = anonymousBefore;
           const simple = parseFastRange(source, contentStart, contentEnd);
           if (simple) {
             reportClauseSingletonWarnings(simple, options.onWarning, options.filename ?? '<input>', lineNumber);
             accept(numbered(simple, lineNumber));
           } else {
+            anonymous = anonymousBefore;
             chunkStartLine = lineNumber;
             chunk = source.slice(lineStart, lineEnd) + '\n';
             if (!flush()) return null;

package/src/program.js

@@ -1269,18 +1269,27 @@ function collectAutoloadClosureDependencies(closure, extraArguments, out, module
 
 function expandAutoloadMetaDependencies(program, dependencies, module = 'user') {
   const seen = new WeakMap();
+  // Most dependencies name a predicate without closure arguments; look each
+  // predicate up once instead of once per call site.
+  const closureModes = new Map();
   for (let i = 0; i < dependencies.length; i++) {
     const dependency = dependencies[i];
     if (dependency.goal == null) continue;
     const caller = dependency.module ?? module;
     const visitKey = `${caller}\u0000${dependency.key}`;
+    let modes = closureModes.get(visitKey);
+    if (modes === undefined) {
+      const group = program.findGroup(dependency.name, dependency.arity, caller);
+      modes = (group?.metaArgumentModes ?? []).filter((mode) =>
+        mode.kind === 'closure' && Number.isSafeInteger(mode.extraArguments) && mode.extraArguments >= 0);
+      closureModes.set(visitKey, modes);
+    }
+    if (modes.length === 0) continue;
     const visits = seen.get(dependency.goal) ?? new Set();
     if (visits.has(visitKey)) continue;
     visits.add(visitKey);
     seen.set(dependency.goal, visits);
-    const group = program.findGroup(dependency.name, dependency.arity, caller);
-    for (const mode of group?.metaArgumentModes ?? []) {
-      if (mode.kind !== 'closure' || !Number.isSafeInteger(mode.extraArguments) || mode.extraArguments < 0) continue;
+    for (const mode of modes) {
       collectAutoloadClosureDependencies(dependency.goal?.args[mode.index], mode.extraArguments, dependencies, caller);
     }
   }
@@ -1716,13 +1725,17 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
   if (fast) {
     const acceptBinary = (headName, head0Type, head0Name, head1Type, head1Name,
         bodyName, body0Type, body0Name, body1Type, body1Name) => {
-      batch.push(new CompactBinaryClause(
+      if (batch.length >= PROGRAM_BUILD_BATCH_SIZE) flush();
+      const clause = new CompactBinaryClause(
         headName, head0Type, head0Name, head1Type, head1Name,
         bodyName, body0Type, body0Name, body1Type, body1Name,
-      ));
-      batch[batch.length - 1].module = context.module;
-      batch[batch.length - 1].textUnit = context.textUnit;
-      if (batch.length >= PROGRAM_BUILD_BATCH_SIZE) flush();
+      );
+      clause.module = context.module;
+      clause.textUnit = context.textUnit;
+      batch.push(clause);
+      // The parser numbers the clause for its source metadata once it is
+      // returned, so the batch is flushed at the next clause, not here.
+      return clause;
     };
     const parsed = tryParseClausesFastInto(source, processClause, acceptBinary, options);
     if (parsed) flush();

package/src/result-format.js

@@ -158,11 +158,24 @@ function renameMinted(value, minted) {
       if (!minted.has(key)) minted.set(key, minted.size + 1);
       return compound('$stream', [numberTerm(BigInt(minted.get(key)))]);
     }
-    return compound(value.name, value.args.map((arg) => renameMinted(arg, minted)));
+    return sameOrRebuilt(value, (arg) => renameMinted(arg, minted));
   }
   return value;
 }
 
+// A compound with `rewrite` applied to its arguments: the compound itself
+// when no argument changes, so ground subterms are shared, not copied.
+function sameOrRebuilt(value, rewrite) {
+  let args = null;
+  for (let i = 0; i < value.args.length; i++) {
+    const arg = value.args[i];
+    const rewritten = rewrite(arg);
+    if (args == null && rewritten !== arg) args = value.args.slice(0, i);
+    if (args != null) args.push(rewritten);
+  }
+  return args == null ? value : compound(value.name, args);
+}
+
 function templateTerm(value, anonymous, minted) {
   if (value.type === VAR) {
     if (value.name !== '_' && !value.name.startsWith('_')) {
@@ -172,7 +185,7 @@ function templateTerm(value, anonymous, minted) {
     if (!anonymous.has(value.name)) anonymous.set(value.name, anonymous.size + 1);
     return compound('anonymous', [numberTerm(BigInt(anonymous.get(value.name)))]);
   }
-  if (value.type === COMPOUND) return compound(value.name, value.args.map((arg) => templateTerm(arg, anonymous, minted)));
+  if (value.type === COMPOUND) return sameOrRebuilt(value, (arg) => templateTerm(arg, anonymous, minted));
   return value;
 }
 
@@ -192,8 +205,16 @@ function clauseTerm(number, clause, minted) {
 
 // The `clause/3` record a proof writes for clause `number`, which a checker
 // rebuilds from the source to compare with the document's (C1).
+// The record is kept with the clause, so a proof checked as it is written
+// compares its records with the very terms the checker rebuilds.
+const clauseRecords = new WeakMap();
+
 export function clauseRecordTerm(number, clause) {
-  return clauseTerm(number, clause, new Map());
+  const cached = clauseRecords.get(clause);
+  if (cached?.number === number) return cached.record;
+  const record = clauseTerm(number, clause, new Map());
+  clauseRecords.set(clause, { number, record });
+  return record;
 }
 
 // A `clause/3` record with its minted variable names renumbered from the

package/src/write.js

@@ -250,7 +250,11 @@ function printableReadVariableNames(term, env, explicit) {
   const used = new Set(names.values());
   const suffixes = new Map();
   const seenVariables = new Set();
-  const seenTerms = new Set();
+  // A subterm shared many times over is walked once. Most terms are small
+  // trees, where walking a subterm again changes nothing, so the set is only
+  // kept once a term turns out to be large.
+  let seenTerms = null;
+  let walked = 0;
   const stack = [term];
 
   while (stack.length) {
@@ -268,8 +272,12 @@ function printableReadVariableNames(term, env, explicit) {
       used.add(candidate);
       continue;
     }
-    if (current.type !== COMPOUND || seenTerms.has(current)) continue;
-    seenTerms.add(current);
+    if (current.type !== COMPOUND) continue;
+    if (seenTerms == null && ++walked > 4096) seenTerms = new Set();
+    if (seenTerms != null) {
+      if (seenTerms.has(current)) continue;
+      seenTerms.add(current);
+    }
     for (let i = current.arity - 1; i >= 0; i--) stack.push(current.args[i]);
   }
 

package/test/regression/cases-regression.mjs

@@ -6025,6 +6025,40 @@ answer(Result) :- countdown(2048, Result), Result = 2048.
         }
       },
     },
+    {
+      name: 'with source metadata, compact binary clauses are numbered and named exactly as the general parser reads them',
+      run: () => {
+        // A proof cites clauses by the numbers source metadata gives them, so
+        // a program loaded through the compact binary-clause path for --proof
+        // must carry the numbers, lines and anonymous-variable names the
+        // general parser gives the same text -- including after a clause the
+        // compact path reads part of and then declines.
+        const source = [
+          'a(ind, n0).',
+          'a(X, n1) :- a(X, n0).',
+          'b(_, _).',
+          'c(X, Y) :- a(X, _), b(Y, _).',
+          'a(_, n2) :- a(_, n1).',
+          'd(f(_), _).',
+          'p(_, x) :- q(f(_), x).',
+          'e(X, _) :- a(X, n2).',
+          '',
+        ].join('\n');
+        // Variables by their internal names, which a printed term hides.
+        const named = (term) => term.type === 'var'
+          ? term.name
+          : term.type === 'compound' ? `${term.name}(${term.args.map(named).join(',')})` : String(term.name);
+        const spelled = (clause) => [
+          clause.source?.line,
+          clause.source?.clause,
+          named(clause.head),
+          (clause.body ?? []).map(named).join(', '),
+        ].join(' | ');
+        const loaded = Program.parse(source, { sourceMetadata: true }).clauses.map(spelled);
+        const general = parseProgramText(source, { sourceMetadata: true, generalParser: true }).map(spelled);
+        assertEqual(loaded.join('\n'), general.join('\n'), 'the loaded clauses');
+      },
+    },
     {
       // https://github.com/eyereasoner/eyeprolog/issues/114#issuecomment-5663598188
       name: 'a genuine IEEE-754 negative zero produced by arithmetic (not just parsed from text) still prints as 0.0',