eyeprolog 1.4.7 → 1.4.9

package/package.json

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

package/src/cli.js

@@ -154,6 +154,7 @@ export async function main(argv) {
     isoStrict: options.isoStrict,
     autoload: options.autoload,
     autoloadGoals: options.goals,
+    onWarning: printSourceWarning,
   });
 
   const portabilityFailures = program.interopPortabilityWarnings ?? [];
@@ -271,6 +272,13 @@ function readStdin() {
   });
 }
 
+
+function printSourceWarning(warning) {
+  if (warning.kind !== 'singleton') return;
+  process.stderr.write(`Warning: singleton: ${warning.name}, near ${warning.filename}:${warning.line}
+`);
+}
+
 function printWarnings(program) {
   for (const warning of program.interopPortabilityWarnings ?? []) {
     if (warning.kind === 'library') {

package/src/parser.js

@@ -246,6 +246,8 @@ class Parser {
     this.anonymous = 0;
     this.variables = new Map();
     this.sourceMetadata = options.sourceMetadata !== false;
+    this.onWarning = typeof options.onWarning === 'function' ? options.onWarning : null;
+    this.currentSourceTermLine = 1;
     this.strictIso = options.isoStrict === true;
     this.parserFlagState = options.parserFlagState ?? {
       doubleQuotes: options.doubleQuotes ?? 'chars',
@@ -1010,9 +1012,14 @@ class Parser {
   parseProgram(emit = null) {
     const clauses = emit ? null : [];
     let clauseNumber = 0;
-    const accept = emit ?? ((clause) => clauses.push(clause));
+    const rawAccept = emit ?? ((clause) => clauses.push(clause));
+    const accept = (item) => {
+      reportClauseSingletonWarnings(item, this.onWarning, this.filename, this.currentSourceTermLine);
+      rawAccept(item);
+    };
     while (this.token.type !== TOK.EOF) {
       const line = this.token.line;
+      this.currentSourceTermLine = line;
       // Prefix operator notation needs one program-level distinction so
       // a comma in `?- A, B.` remains inside the query rather than outside the
       // prefix term. Ordinary functional notation is parsed as a term and then
@@ -1226,6 +1233,29 @@ function listAtomNames(term) {
 }
 
 
+function collectClauseVariableOccurrences(term, counts) {
+  if (term == null) return;
+  if (term.type === 'var') {
+    counts.set(term.name, (counts.get(term.name) ?? 0) + 1);
+    return;
+  }
+  if (term.type === COMPOUND) {
+    for (const arg of term.args) collectClauseVariableOccurrences(arg, counts);
+  }
+}
+
+function reportClauseSingletonWarnings(clause, onWarning, filename, line) {
+  if (typeof onWarning !== 'function' || clause?.kind === 'quad') return;
+  const counts = new Map();
+  collectClauseVariableOccurrences(clause.head, counts);
+  for (const goal of clause.body ?? []) collectClauseVariableOccurrences(goal, counts);
+  for (const [name, count] of counts) {
+    if (count !== 1 || String(name).startsWith('_')) continue;
+    onWarning({ kind: 'singleton', name, filename: filename ?? '<input>', line });
+  }
+}
+
+
 export function parseClauses(source, options = {}) {
   const ownsParserFlagState = options.parserFlagState == null;
   const initialDoubleQuotes = options.doubleQuotes ?? 'chars';
@@ -1282,6 +1312,7 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
   const accept = emit ?? ((clause) => clauses.push(clause));
   let anonymous = 0;
   let chunk = '';
+  let chunkStartLine = 1;
 
   const cached = (cache, key, create) => {
     const existing = cache.get(key);
@@ -1466,12 +1497,42 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     return -1;
   };
 
-  const emitFastBinaryRange = (text, start, end) => {
+  const reportFastBinarySingletonWarnings = (head, body, line) => {
+    if (typeof options.onWarning !== 'function') return;
+    const variables = [];
+    const add = (type, name) => {
+      if (type !== 'var' || String(name).startsWith('_')) return;
+      variables.push(name);
+    };
+    add(head.arg0Type, head.arg0Name);
+    add(head.arg1Type, head.arg1Name);
+    if (body != null) {
+      add(body.arg0Type, body.arg0Name);
+      add(body.arg1Type, body.arg1Name);
+    }
+    for (let i = 0; i < variables.length; i++) {
+      let count = 0;
+      for (let j = 0; j < variables.length; j++) {
+        if (variables[i] === variables[j]) count++;
+      }
+      if (count === 1) {
+        options.onWarning({
+          kind: 'singleton',
+          name: variables[i],
+          filename: options.filename ?? '<input>',
+          line,
+        });
+      }
+    }
+  };
+
+  const emitFastBinaryRange = (text, start, end, line) => {
     if (!emitBinary || start >= end || text.charCodeAt(end - 1) !== 46) return false;
     const termEnd = end - 1;
     const rule = findRuleInRange(text, start, termEnd);
     if (rule < 0) {
       if (!parseBinaryRawRange(text, start, termEnd, rawHead)) return false;
+      reportFastBinarySingletonWarnings(rawHead, null, line);
       emitBinary(rawHead.name,
         rawHead.arg0Type, rawHead.arg0Name, rawHead.arg1Type, rawHead.arg1Name,
         null, null, null, null, null);
@@ -1480,6 +1541,7 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     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,
       rawHead.arg0Type, rawHead.arg0Name, rawHead.arg1Type, rawHead.arg1Name,
       rawBody.name, rawBody.arg0Type, rawBody.arg0Name, rawBody.arg1Type, rawBody.arg1Name);
@@ -1541,6 +1603,7 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
 
   const flush = () => {
     const text = chunk.trim();
+    const sourceLine = chunkStartLine;
     chunk = '';
     if (!text) return true;
     // Once a preparation-time char_conversion/2 mapping is active, every
@@ -1549,11 +1612,15 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     // here would silently bypass Convc for otherwise simple clauses.
     const simple = preparationConversionActive() ? null : parseSimple(text);
     if (simple) {
+      reportClauseSingletonWarnings(simple, options.onWarning, options.filename ?? '<input>', sourceLine);
       accept(simple);
       return true;
     }
     try {
-      const parsed = new Parser(text, { ...options, sourceMetadata: false }).parseProgram();
+      const nestedWarning = typeof options.onWarning === 'function'
+        ? (warning) => options.onWarning({ ...warning, line: warning.line + sourceLine - 1 })
+        : null;
+      const parsed = new Parser(text, { ...options, sourceMetadata: false, onWarning: nestedWarning }).parseProgram();
       for (const clause of parsed) accept(clause);
       return true;
     } catch (_) {
@@ -1562,6 +1629,7 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
   };
 
   let lineStart = 0;
+  let lineNumber = 1;
   while (lineStart <= source.length) {
     let lineEnd = source.indexOf('\n', lineStart);
     if (lineEnd < 0) lineEnd = source.length;
@@ -1571,17 +1639,21 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     [contentStart, contentEnd] = trimRange(source, contentStart, contentEnd);
     if (contentStart < contentEnd && source.charCodeAt(contentStart) !== 37) {
       if (!chunk && source.charCodeAt(contentEnd - 1) === 46 && !preparationConversionActive()) {
-        if (emitFastBinaryRange(source, contentStart, contentEnd)) {
+        if (emitFastBinaryRange(source, contentStart, contentEnd, lineNumber)) {
           // The program builder accepted a compact binary clause directly.
         } else {
           const simple = parseFastRange(source, contentStart, contentEnd);
-          if (simple) accept(simple);
-          else {
+          if (simple) {
+            reportClauseSingletonWarnings(simple, options.onWarning, options.filename ?? '<input>', lineNumber);
+            accept(simple);
+          } else {
+            chunkStartLine = lineNumber;
             chunk = source.slice(lineStart, lineEnd) + '\n';
             if (!flush()) return null;
           }
         }
       } else {
+        if (!chunk) chunkStartLine = lineNumber;
         chunk += source.slice(lineStart, lineEnd) + '\n';
         if (source.charCodeAt(contentEnd - 1) === 46) {
           if (!flush()) return null;
@@ -1590,6 +1662,7 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     }
     if (lineEnd === source.length) break;
     lineStart = lineEnd + 1;
+    lineNumber++;
   }
   if (chunk.trim() && !flush()) return null;
   return clauses ?? true;

package/src/program.js

@@ -1390,7 +1390,7 @@ function readModuleSource(designation, options) {
     return {
       name,
       text: registered.source,
-      options: { ...options, filename: registered.filename, baseDir: 'src/lib' },
+      options: { ...options, filename: registered.filename, baseDir: 'src/lib', onWarning: null },
     };
   }
   if (designation.type !== ATOM) throw new PrologError('type_error(source_sink)', designation);

package/test/run-examples.mjs

@@ -214,6 +214,11 @@ function runProgramExample(programFile, filename, options) {
   const expectedExit = text.match(/^%\s*expect-exit:\s*(\d+)\s*$/m);
   const program = Program.parseSources([{ text, filename }], {
     sourceMetadata: options.proof,
+    onWarning: (warning) => {
+      if (warning.kind === 'singleton') {
+        process.stderr.write(`Warning: singleton: ${warning.name}, near ${warning.filename}:${warning.line}\n`);
+      }
+    },
   });
   try {
     const result = run(program, { ...options, goals: goalsInProgramOrder(program, text) });

package/test/run-regression.mjs

@@ -45,7 +45,7 @@ import {
   variantTerms,
   parseProgramText,
 } from '../src/index.js';
-import { ISO_OPERATOR_DEFINITIONS, parseGoalText, parseNumberTokenText } from '../src/parser.js';
+import { ISO_OPERATOR_DEFINITIONS, parseGoalText, parseNumberTokenText, tryParseClausesFastInto } from '../src/parser.js';
 import { PrologError, formalErrorTerm } from '../src/iso.js';
 import { compareTerms } from '../src/term.js';
 import { formatTermForWrite } from '../src/write.js';
@@ -4062,6 +4062,38 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
         assertIncludes(result.stderr, '/(member, 2)', 'stderr');
       },
     },
+    {
+      name: 'CLI reports singleton source variables without a corpus-wide warning scan',
+      run: () => {
+        const input = 'p(X, Once, _Ignored, _) :- q(X).\nq(a).\n';
+        const result = runCli(['-'], { input });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout, '', 'stdout');
+        assertEqual(result.stderr, 'Warning: singleton: Once, near <stdin>:1\n', 'stderr');
+      },
+    },
+    {
+      name: 'singleton warnings preserve the compact binary parser path',
+      run: () => {
+        const clauses = [];
+        const binary = [];
+        const warnings = [];
+        const parsed = tryParseClausesFastInto(
+          'p(X,Y) :- q(X,a).\n',
+          (clause) => clauses.push(clause),
+          (...args) => binary.push(args),
+          { filename: 'fast.pl', onWarning: (warning) => warnings.push(warning) },
+        );
+        assertEqual(parsed, true, 'fast parse result');
+        assertEqual(clauses.length, 0, 'materialized clause count');
+        assertEqual(binary.length, 1, 'direct binary clause count');
+        assertEqual(warnings.length, 1, 'warning count');
+        assertEqual(warnings[0].kind, 'singleton', 'warning kind');
+        assertEqual(warnings[0].name, 'Y', 'warning variable');
+        assertEqual(warnings[0].filename, 'fast.pl', 'warning filename');
+        assertEqual(warnings[0].line, 1, 'warning line');
+      },
+    },
     {
       name: '--warnings flags explicit library(prologue) dependencies',
       run: () => {
@@ -4648,64 +4680,8 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
 
 
 
-function topLevelRunnableExampleFiles() {
-  const examplesDir = path.join(packageRoot, 'examples');
-  return fs.readdirSync(examplesDir)
-    .filter((name) => name.endsWith('.pl'))
-    .sort()
-    .map((name) => path.join(examplesDir, name));
-}
-
-function visitTermVariables(term, counts, seen = new Set()) {
-  if (term == null) return;
-  if (term.type === 'var') {
-    // The parser preserves identity for repeated source variables. Count every
-    // occurrence so only variables that occur once syntactically are flagged.
-    counts.set(term.name, (counts.get(term.name) ?? 0) + 1);
-    return;
-  }
-  if (seen.has(term)) return;
-  seen.add(term);
-  if (term.type === 'compound') {
-    for (const arg of term.args) visitTermVariables(arg, counts, seen);
-  }
-}
-
-function singletonVariableWarningsForClause(clause) {
-  const counts = new Map();
-  visitTermVariables(clause.head, counts);
-  for (const goal of clause.body ?? []) visitTermVariables(goal, counts);
-  return [...counts]
-    .filter(([name, count]) => count === 1 && !String(name).startsWith('_'))
-    .map(([name]) => name);
-}
-
-function singletonVariableWarningsForRunnableExamples() {
-  const warnings = [];
-  for (const filename of topLevelRunnableExampleFiles()) {
-    const text = fs.readFileSync(filename, 'utf8');
-    const program = Program.parseSources([{ text, filename }], { sourceMetadata: true });
-    for (const clause of program.clauses) {
-      if (path.resolve(clause.source?.filename ?? '') !== path.resolve(filename)) continue;
-      for (const name of singletonVariableWarningsForClause(clause)) {
-        warnings.push(`singleton: ${name}, near ${path.relative(packageRoot, filename)}:${clause.source?.line ?? '?'}`);
-      }
-    }
-  }
-  return warnings;
-}
-
 function documentationSyncCases() {
   return [
-    {
-      name: 'runnable examples are free of singleton-variable warnings',
-      run: () => {
-        const warnings = singletonVariableWarningsForRunnableExamples();
-        if (warnings.length !== 0) {
-          throw new Error(`example singleton-variable warnings\n${warnings.join('\n')}`);
-        }
-      },
-    },
     {
       name: 'WG17 syntax status matches its executable-coverage manifest',
       run: () => {