eyeprolog 1.2.44 → 1.3.1

package/src/program.js

@@ -10,11 +10,17 @@ import {
   createParserOperatorState,
   parseClauses,
   parseClausesInto,
+  parseGoalText,
   tryParseClausesFastInto,
 } from './parser.js';
 import { PrologError, getStrictIsoRegistry } from './iso.js';
 import { currentWorkingDirectory, fs, path } from './platform.js';
-import { standardLibrarySources } from './standard-library.js';
+import {
+  standardLibrarySources,
+  eyePrologInteropAutoload,
+  eyePrologInteropLibraryIndicators,
+  eyePrologInteropLibraryModules,
+} from './standard-library.js';
 import { expandDcgRuleClause } from './dcg.js';
 
 const DEFER_PROGRAM_BUILD = Symbol('deferProgramBuild');
@@ -102,6 +108,9 @@ export class Program {
     this.modules = new Map([['user', { name: 'user', exports: new Map(), filename: '<input>' }]]);
     this.moduleImports = new Map();
     this.moduleMetaPredicates = new Map();
+    this.autoloadedPredicates = [];
+    this.libraryImports = [];
+    this.interopPortabilityWarnings = [];
     this.dynamicPredicates = new Set();
     this.strictIso = options.isoStrict === true;
     this.operators = new Map();
@@ -677,6 +686,19 @@ function loadSourcesIntoBuilder(builder, sources, options, fast) {
       const context = { module: 'user' };
       if (!loadSourceIntoBuilder(builder, text, item.options, ensured, loadedModules, fast, context)) return false;
     }
+    const autoloadGoals = parseInteropGoalInputs(options.autoloadGoals, {
+      ...options,
+      operatorState,
+      parserFlagState,
+    }, builder.program);
+    if (options.isoStrict !== true && options.autoload !== false) {
+      autoloadInteropDependencies(builder, {
+        ...options,
+        operatorState,
+        parserFlagState,
+      }, ensured, loadedModules, autoloadGoals);
+    }
+    analyzeInteropPortability(builder.program, autoloadGoals);
     builder.program.doubleQuotes = parserFlagState.doubleQuotes;
     return true;
   } catch (error) {
@@ -685,6 +707,208 @@ function loadSourcesIntoBuilder(builder, sources, options, fast) {
   }
 }
 
+
+const interopIndicatorSet = new Set(eyePrologInteropLibraryIndicators);
+const interopLibraryModuleSet = new Set(eyePrologInteropLibraryModules);
+
+function libraryDesignationName(designation) {
+  return designation?.type === COMPOUND && designation.name === 'library' && designation.arity === 1 &&
+    designation.args[0]?.type === ATOM
+    ? designation.args[0].name
+    : null;
+}
+
+function bundledLibraryModule(program, module) {
+  return module !== 'user' && program.modules.get(module)?.filename?.startsWith('src/lib/');
+}
+
+function groupDependencies(group) {
+  const dependencies = [];
+  for (const clause of group.clauses) {
+    if (isCompactBinaryClause(clause)) {
+      if (clause.bodyName != null) {
+        dependencies.push({
+          key: `${clause.bodyName}/2`,
+          name: clause.bodyName,
+          arity: 2,
+          module: clause.module ?? group.module,
+        });
+      }
+      continue;
+    }
+    for (const goal of clause.body) {
+      dependencies.push(...collectGoalDependencies(goal, false, true));
+    }
+  }
+  return dependencies;
+}
+
+function parseInteropGoalInputs(inputs, options, program) {
+  if (inputs == null) return [];
+  const values = Array.isArray(inputs) ? inputs : [inputs];
+  return values.filter((value) => value != null).map((value) => {
+    if (typeof value !== 'string') return value;
+    return parseGoalText(value, {
+      doubleQuotes: options.parserFlagState?.doubleQuotes ?? options.doubleQuotes ?? program.doubleQuotes ?? 'chars',
+      operatorDefinitions: [...program.operators.values()],
+      isoStrict: options.isoStrict === true,
+    });
+  });
+}
+
+function extraGoalDependencies(goals) {
+  const dependencies = [];
+  for (const goal of goals) dependencies.push(...collectGoalDependencies(goal, false, true));
+  return dependencies;
+}
+
+function interopAutoloadRequests(program, extraGoals = []) {
+  const requests = new Map();
+  for (const group of program.groups.values()) {
+    if (bundledLibraryModule(program, group.module)) continue;
+    for (const dependency of groupDependencies(group)) {
+      const targetModule = dependency.module ?? group.module;
+      if (program.findGroup(dependency.name, dependency.arity, targetModule)) continue;
+      const library = eyePrologInteropAutoload[dependency.key];
+      if (library == null) continue;
+      const requestKey = `${targetModule}\u0000${dependency.key}`;
+      requests.set(requestKey, {
+        targetModule,
+        library,
+        name: dependency.name,
+        arity: dependency.arity,
+        key: dependency.key,
+      });
+    }
+  }
+  for (const goal of program.initializations) {
+    for (const dependency of collectGoalDependencies(goal, false, true)) {
+      const targetModule = dependency.module ?? 'user';
+      if (program.findGroup(dependency.name, dependency.arity, targetModule)) continue;
+      const library = eyePrologInteropAutoload[dependency.key];
+      if (library == null) continue;
+      const requestKey = `${targetModule}\u0000${dependency.key}`;
+      requests.set(requestKey, {
+        targetModule,
+        library,
+        name: dependency.name,
+        arity: dependency.arity,
+        key: dependency.key,
+      });
+    }
+  }
+  for (const dependency of extraGoalDependencies(extraGoals)) {
+    const targetModule = dependency.module ?? 'user';
+    if (program.findGroup(dependency.name, dependency.arity, targetModule)) continue;
+    const library = eyePrologInteropAutoload[dependency.key];
+    if (library == null) continue;
+    const requestKey = `${targetModule}\u0000${dependency.key}`;
+    requests.set(requestKey, {
+      targetModule,
+      library,
+      name: dependency.name,
+      arity: dependency.arity,
+      key: dependency.key,
+    });
+  }
+  return [...requests.values()];
+}
+
+function autoloadInteropDependencies(builder, options, ensured, loadedModules, extraGoals = []) {
+  const program = builder.program;
+  while (true) {
+    const requests = interopAutoloadRequests(program, extraGoals);
+    if (requests.length === 0) return;
+    let changed = false;
+    for (const request of requests) {
+      if (program.findGroup(request.name, request.arity, request.targetModule)) continue;
+      if (!loadedModules.has(request.library)) {
+        const designation = compound('library', [atom(request.library)]);
+        const loaded = readModuleSource(designation, options);
+        const childContext = { module: loaded.name };
+        // Bundled library sources are small and directive-heavy.  Parse them
+        // with the general parser even when the user source took the compact
+        // fast path; this avoids rebuilding otherwise-fast user programs.
+        if (!loadSourceIntoBuilder(
+          builder, loaded.text, loaded.options, ensured, loadedModules, false, childContext,
+        )) {
+          throw new Error(`could not autoload library(${request.library})`);
+        }
+      }
+      program.importModule(request.targetModule, request.library, [request]);
+      program.autoloadedPredicates.push({
+        targetModule: request.targetModule,
+        library: request.library,
+        indicator: request.key,
+      });
+      changed = true;
+    }
+    if (!changed) return;
+  }
+}
+
+function analyzeInteropPortability(program, extraGoals = []) {
+  const warnings = new Map();
+  const nonInteropImports = new Map();
+  for (const entry of program.libraryImports) {
+    if (bundledLibraryModule(program, entry.targetModule)) continue;
+    if (!interopLibraryModuleSet.has(entry.library)) {
+      warnings.set(`library:${entry.targetModule}:${entry.library}`, {
+        kind: 'library',
+        library: entry.library,
+        targetModule: entry.targetModule,
+      });
+      const libraries = nonInteropImports.get(entry.targetModule) ?? new Set();
+      libraries.add(entry.library);
+      nonInteropImports.set(entry.targetModule, libraries);
+      continue;
+    }
+    if (entry.imports != null) {
+      for (const indicator of entry.imports) {
+        if (interopIndicatorSet.has(indicator.key)) continue;
+        warnings.set(`predicate:${entry.targetModule}:${entry.library}:${indicator.key}`, {
+          kind: 'predicate',
+          library: entry.library,
+          indicator: indicator.key,
+          targetModule: entry.targetModule,
+        });
+      }
+    }
+  }
+
+  for (const group of program.groups.values()) {
+    if (bundledLibraryModule(program, group.module)) continue;
+    for (const dependency of groupDependencies(group)) {
+      const targetModule = dependency.module ?? group.module;
+      const resolved = program.findGroup(dependency.name, dependency.arity, targetModule);
+      if (!resolved || !bundledLibraryModule(program, resolved.module)) continue;
+      if (interopIndicatorSet.has(dependency.key)) continue;
+      if (nonInteropImports.get(targetModule)?.has(resolved.module)) continue;
+      warnings.set(`predicate:${targetModule}:${resolved.module}:${dependency.key}`, {
+        kind: 'predicate',
+        library: resolved.module,
+        indicator: dependency.key,
+        targetModule,
+      });
+    }
+  }
+
+  for (const dependency of extraGoalDependencies(extraGoals)) {
+    const targetModule = dependency.module ?? 'user';
+    const resolved = program.findGroup(dependency.name, dependency.arity, targetModule);
+    if (!resolved || !bundledLibraryModule(program, resolved.module)) continue;
+    if (interopIndicatorSet.has(dependency.key)) continue;
+    if (nonInteropImports.get(targetModule)?.has(resolved.module)) continue;
+    warnings.set(`predicate:${targetModule}:${resolved.module}:${dependency.key}`, {
+      kind: 'predicate',
+      library: resolved.module,
+      indicator: dependency.key,
+      targetModule,
+    });
+  }
+  program.interopPortabilityWarnings = [...warnings.values()];
+}
+
 function sourceOptionsFor(source, options) {
   if (typeof source === 'string') return options;
   return {
@@ -736,6 +960,14 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
       flush();
       clause.module = context.module;
       builder.addClauses([clause]);
+      const libraryName = libraryDesignationName(use.designation);
+      if (libraryName != null) {
+        builder.program.libraryImports.push({
+          targetModule: context.module,
+          library: libraryName,
+          imports: use.imports == null ? null : use.imports.map((indicator) => ({ ...indicator })),
+        });
+      }
       const loaded = readModuleSource(use.designation, options);
       if (!loadedModules.has(loaded.name)) {
         const childContext = { module: loaded.name };

package/src/standard-library.js

@@ -1,7 +1,7 @@
 // ISO/IEC 13211-2 module sources shipped with EyeProlog.
-// The sources are registered here so library(Name) works in Node and browsers;
-// unlike the former autoloader, no clauses are added unless use_module/1 or
-// use_module/2 requests their module.
+// The sources are registered here so library(Name) works in Node and browsers.
+// Modules are loaded on demand by explicit use_module/1-2 or by the conservative
+// source-level interop autoloader declared below.
 import { PrologError, createDefaultRegistry, eyePrologLibraryBuiltins } from './iso.js';
 import { clpzBuiltins } from './clpz.js';
 import { fs, isNode, memoryStatistics } from './platform.js';
@@ -62,8 +62,8 @@ export const eyePrologPortableLibraryIndicators = Object.freeze([
   'maplist/6', 'maplist/7', 'maplist/8', 'between/3',
   'smallest_divisor_from/3', 'random/3', 'matches/3', 'split/3',
   'replace/4', 'lowercase/2', 'uppercase/2', 'trim/2', 'number_string/2',
-  'atom_string/2', 'term_string/2', 'append/3', 'string_concat/3', 'contains/2',
-  'matches/2', 'join/3', 'substring/4', 'member/2', 'select/3', 'last/2',
+  'atom_string/2', 'term_string/2', 'append/2', 'append/3', 'string_concat/3', 'contains/2',
+  'matches/2', 'join/3', 'substring/4', 'member/2', 'memberchk/2', 'select/3', 'last/2', 'same_length/2',
   'nth0/3', 'nth0/4', 'nth1/3', 'nth1/4', 'set_nth0/4', 'take/3', 'drop/3', 'slice/4', 'reverse/2',
   'length/2', 'sum_list/2', 'min_list/2', 'max_list/2', 'list_to_set/2',
   'succ/2', 'foldl/4', 'foldl/5', 'foldl/6',
@@ -74,6 +74,61 @@ export const eyePrologLibraryIndicators = Object.freeze([
   ...eyePrologNativeLibraryIndicators,
 ]);
 
+
+// Conservative cross-implementation profile.  These predicate indicators are
+// intentionally limited to interfaces that EyeProlog wants to keep source-
+// compatible with the Trealla/Scryer ecosystem.  The value is the canonical
+// EyeProlog library used when an otherwise undefined call is autoloaded.
+//
+// This is deliberately separate from eyePrologPortableLibraryIndicators:
+// "portable" there means implemented in Prolog rather than as a host builtin;
+// this table means interoperable source-level API.
+export const eyePrologInteropAutoload = Object.freeze({
+  'member/2': 'lists',
+  'memberchk/2': 'lists',
+  'select/3': 'lists',
+  'append/2': 'lists',
+  'append/3': 'lists',
+  'last/2': 'lists',
+  'same_length/2': 'lists',
+  'nth0/3': 'lists',
+  'nth0/4': 'lists',
+  'nth1/3': 'lists',
+  'nth1/4': 'lists',
+  'reverse/2': 'lists',
+  'length/2': 'lists',
+  'maplist/2': 'lists',
+  'maplist/3': 'lists',
+  'maplist/4': 'lists',
+  'maplist/5': 'lists',
+  'maplist/6': 'lists',
+  'maplist/7': 'lists',
+  'maplist/8': 'lists',
+  'foldl/4': 'lists',
+  'foldl/5': 'lists',
+  'foldl/6': 'lists',
+  'sum_list/2': 'lists',
+  'list_to_set/2': 'lists',
+  // call_nth/2 is available in both Trealla and Scryer (the latter via
+  // library(iso_ext)).  EyeProlog keeps its adapter in library(prologue), so
+  // autoloading hides that implementation-specific location from source.
+  'call_nth/2': 'prologue',
+  // Trealla and Scryer expose between/3 without an EyeProlog-style
+  // library(prologue) dependency.  EyeProlog keeps its implementation in the
+  // Prologue module but autoloads it so portable source need not name that
+  // implementation-specific library.
+  'between/3': 'prologue',
+});
+
+export const eyePrologInteropLibraryIndicators = Object.freeze(
+  Object.keys(eyePrologInteropAutoload),
+);
+
+// Libraries whose *name* is part of the current interop profile.  A program
+// may freely use_module(library(lists)); predicates in that module which are
+// outside eyePrologInteropLibraryIndicators are still diagnosed when used.
+export const eyePrologInteropLibraryModules = Object.freeze(['lists']);
+
 function runtimeStatistics(solver) {
   return { ...solver.stats, ...memoryStatistics() };
 }

package/test/run-interop.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+// Cross-implementation smoke tests for source-level Prolog interoperability.
+//
+// By default this runner requires Trealla (`tpl`) and Scryer (`scryer-prolog`)
+// to be installed.  Pass --allow-missing for local development when only the
+// EyeProlog leg is available.
+import path from 'node:path';
+import process from 'node:process';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const allowMissing = process.argv.includes('--allow-missing');
+const sudoku = path.join(root, 'examples', 'sudoku.pl');
+const goal = 'sudoku_solution(S), write(S), nl, fail; halt';
+const expected = '[[5,3,4,6,7,8,9,1,2],[6,7,2,1,9,5,3,4,8],[1,9,8,3,4,2,5,6,7],[8,5,9,7,6,1,4,2,3],[4,2,6,8,5,3,7,9,1],[7,1,3,9,2,4,8,5,6],[9,6,1,5,3,7,2,8,4],[2,8,7,4,1,9,6,3,5],[3,4,5,2,8,6,1,7,9]]';
+
+const engines = [
+  {
+    name: 'EyeProlog',
+    command: process.execPath,
+    args: [path.join(root, 'bin', 'eyeprolog.js'), '--portable', '-g', goal, sudoku],
+  },
+  {
+    name: 'Trealla',
+    command: process.env.TPL ?? 'tpl',
+    args: ['-q', '-g', goal, sudoku],
+  },
+  {
+    name: 'Scryer',
+    command: process.env.SCRYER_PROLOG ?? 'scryer-prolog',
+    args: ['-f', '-g', goal, sudoku],
+  },
+];
+
+let failed = false;
+let executed = 0;
+for (const engine of engines) {
+  const result = spawnSync(engine.command, engine.args, {
+    cwd: root,
+    encoding: 'utf8',
+    timeout: 120000,
+  });
+  if (result.error?.code === 'ENOENT') {
+    if (allowMissing && engine.name !== 'EyeProlog') {
+      console.log(`SKIP ${engine.name}: ${engine.command} not installed`);
+      continue;
+    }
+    console.error(`FAIL ${engine.name}: ${engine.command} not installed`);
+    failed = true;
+    continue;
+  }
+  executed++;
+  if (result.error) {
+    console.error(`FAIL ${engine.name}: ${result.error.message}`);
+    failed = true;
+    continue;
+  }
+  if (result.status !== 0) {
+    console.error(`FAIL ${engine.name}: exit ${result.status}`);
+    if (result.stderr) console.error(result.stderr.trim());
+    failed = true;
+    continue;
+  }
+  const lines = String(result.stdout ?? '').split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  if (!lines.includes(expected)) {
+    console.error(`FAIL ${engine.name}: Sudoku output mismatch`);
+    console.error(`stdout: ${JSON.stringify(result.stdout)}`);
+    if (result.stderr) console.error(`stderr: ${result.stderr.trim()}`);
+    failed = true;
+    continue;
+  }
+  console.log(`OK ${engine.name}: portable Sudoku`);
+}
+
+if (failed) process.exitCode = 1;
+else console.log(`OK ${executed}/${allowMissing ? engines.length : executed} available interop engines passed`);