eyeprolog 1.5.55 → 1.5.56

package/examples/combinatorics-findall-sort.pl

@@ -14,16 +14,16 @@
 
 % select/3 nondeterministically removes one item from a list; because it is an
 % ordinary rule, the example also demonstrates user-level list recursion.
-select(Item, [Item | Rest], Rest).
+select_item(Item, [Item | Rest], Rest).
 % The recursive clause keeps the non-selected head and searches the tail.
-select(Item, [Head | Tail], [Head | Rest]) :-
-  select(Item, Tail, Rest).
+select_item(Item, [Head | Tail], [Head | Rest]) :-
+  select_item(Item, Tail, Rest).
 
 % combination/3 builds an unordered K-combination by repeated selection.
 combination(0, _items, []).
 combination(I, Items, Combination) :-
   (I > 0),
-  select(Item, Items, Remaining),
+  select_item(Item, Items, Remaining),
   (J is I - 1),
   combination(J, Remaining, Partial),
   sort([Item | Partial], Combination).

package/examples/d3-group.pl

@@ -21,42 +21,42 @@ symmetry(reflection_b).
 symmetry(reflection_c).
 
 % Cayley table for D3 composition.
-compose(identity, identity, identity).
-compose(identity, rotation_120, rotation_120).
-compose(identity, rotation_240, rotation_240).
-compose(identity, reflection_a, reflection_a).
-compose(identity, reflection_b, reflection_b).
-compose(identity, reflection_c, reflection_c).
-compose(rotation_120, identity, rotation_120).
-compose(rotation_120, rotation_120, rotation_240).
-compose(rotation_120, rotation_240, identity).
-compose(rotation_120, reflection_a, reflection_b).
-compose(rotation_120, reflection_b, reflection_c).
-compose(rotation_120, reflection_c, reflection_a).
-compose(rotation_240, identity, rotation_240).
-compose(rotation_240, rotation_120, identity).
-compose(rotation_240, rotation_240, rotation_120).
-compose(rotation_240, reflection_a, reflection_c).
-compose(rotation_240, reflection_b, reflection_a).
-compose(rotation_240, reflection_c, reflection_b).
-compose(reflection_a, identity, reflection_a).
-compose(reflection_a, rotation_120, reflection_c).
-compose(reflection_a, rotation_240, reflection_b).
-compose(reflection_a, reflection_a, identity).
-compose(reflection_a, reflection_b, rotation_240).
-compose(reflection_a, reflection_c, rotation_120).
-compose(reflection_b, identity, reflection_b).
-compose(reflection_b, rotation_120, reflection_a).
-compose(reflection_b, rotation_240, reflection_c).
-compose(reflection_b, reflection_a, rotation_120).
-compose(reflection_b, reflection_b, identity).
-compose(reflection_b, reflection_c, rotation_240).
-compose(reflection_c, identity, reflection_c).
-compose(reflection_c, rotation_120, reflection_b).
-compose(reflection_c, rotation_240, reflection_a).
-compose(reflection_c, reflection_a, rotation_240).
-compose(reflection_c, reflection_b, rotation_120).
-compose(reflection_c, reflection_c, identity).
+compose_op(identity, identity, identity).
+compose_op(identity, rotation_120, rotation_120).
+compose_op(identity, rotation_240, rotation_240).
+compose_op(identity, reflection_a, reflection_a).
+compose_op(identity, reflection_b, reflection_b).
+compose_op(identity, reflection_c, reflection_c).
+compose_op(rotation_120, identity, rotation_120).
+compose_op(rotation_120, rotation_120, rotation_240).
+compose_op(rotation_120, rotation_240, identity).
+compose_op(rotation_120, reflection_a, reflection_b).
+compose_op(rotation_120, reflection_b, reflection_c).
+compose_op(rotation_120, reflection_c, reflection_a).
+compose_op(rotation_240, identity, rotation_240).
+compose_op(rotation_240, rotation_120, identity).
+compose_op(rotation_240, rotation_240, rotation_120).
+compose_op(rotation_240, reflection_a, reflection_c).
+compose_op(rotation_240, reflection_b, reflection_a).
+compose_op(rotation_240, reflection_c, reflection_b).
+compose_op(reflection_a, identity, reflection_a).
+compose_op(reflection_a, rotation_120, reflection_c).
+compose_op(reflection_a, rotation_240, reflection_b).
+compose_op(reflection_a, reflection_a, identity).
+compose_op(reflection_a, reflection_b, rotation_240).
+compose_op(reflection_a, reflection_c, rotation_120).
+compose_op(reflection_b, identity, reflection_b).
+compose_op(reflection_b, rotation_120, reflection_a).
+compose_op(reflection_b, rotation_240, reflection_c).
+compose_op(reflection_b, reflection_a, rotation_120).
+compose_op(reflection_b, reflection_b, identity).
+compose_op(reflection_b, reflection_c, rotation_240).
+compose_op(reflection_c, identity, reflection_c).
+compose_op(reflection_c, rotation_120, reflection_b).
+compose_op(reflection_c, rotation_240, reflection_a).
+compose_op(reflection_c, reflection_a, rotation_240).
+compose_op(reflection_c, reflection_b, rotation_120).
+compose_op(reflection_c, reflection_c, identity).
 % Each candidate subgroup must also contain inverses.
 inverse(identity, identity).
 inverse(rotation_120, rotation_240).
@@ -78,7 +78,7 @@ all_symmetries(Symmetries) :-
 
 % A valid subgroup is closed under both composition and inverse.
 closed_under_composition(Group) :-
-  \+ (member(X, Group), member(Y, Group), compose(X, Y, Z), \+ member(Z, Group)).
+  \+ (member(X, Group), member(Y, Group), compose_op(X, Y, Z), \+ member(Z, Group)).
 
 closed_under_inverse(Group) :-
   \+ (member(X, Group), inverse(X, Y), \+ member(Y, Group)).

package/examples/eulerian-path.pl

@@ -39,9 +39,9 @@ incident(V, E) :- edge(E, _u, V).
 adjacent_by_edge(V, U, E) :- edge(E, V, U).
 adjacent_by_edge(V, U, E) :- edge(E, U, V).
 
-select(Item, [Item | Rest], Rest).
-select(Item, [Head | Tail], [Head | Rest]) :-
-  select(Item, Tail, Rest).
+select_item(Item, [Item | Rest], Rest).
+select_item(Item, [Head | Tail], [Head | Rest]) :-
+  select_item(Item, Tail, Rest).
 
 % Eulerian paths start at an odd-degree vertex when exactly two exist.
 odd_degree(V) :-
@@ -77,7 +77,7 @@ eulerian_path(Path) :-
 dfs_euler(_current, Path, [], Path).
 dfs_euler(Current, Visited, Remaining, Path) :-
   adjacent_by_edge(Current, Next, Edge),
-  select(Edge, Remaining, Newremaining),
+  select_item(Edge, Remaining, Newremaining),
   dfs_euler(Next, [Next | Visited], Newremaining, Path).
 
 oddVertices(eulerian_path_case, Odds) :-

package/examples/graph-reachability.pl

@@ -18,14 +18,14 @@ edge(d, f).
 edge(e, f).
 edge(f, g).
 
-reachable(Node, Node, _visited).
-reachable(Start, Goal, Visited) :-
+reachable_via(Node, Node, _visited).
+reachable_via(Start, Goal, Visited) :-
   edge(Start, Next),
   \+ member(Next, Visited),
-  reachable(Next, Goal, [Next|Visited]).
+  reachable_via(Next, Goal, [Next|Visited]).
 
 is_reachable(Start, Goal) :-
-  reachable(Start, Goal, [Start]).
+  reachable_via(Start, Goal, [Start]).
 
 reachable(reachability_case, path(a, f)) :-
   is_reachable(a, f).

package/examples/monkey-bananas.pl

@@ -20,16 +20,16 @@ plan(Moves) :-
   candidate_plan(Moves),
   initial_state(I),
   goal_state(G),
-  reachable(I, Moves, G).
+  reachable_state(I, Moves, G).
 
 candidate_plan([_, _, _]).
 candidate_plan([_, _, _, _]).
 candidate_plan([_, _, _, _, _]).
 
-reachable(S, [], S).
-reachable(S1, [M|L], S3) :-
+reachable_state(S, [], S).
+reachable_state(S1, [M|L], S3) :-
   legal_move(S1, M, S2),
-  reachable(S2, L, S3).
+  reachable_state(S2, L, S3).
 
 initial_state([loc1, loc2, loc3, n, n]).
 goal_state([_, _, _, _, y]).

package/examples/proof/graph-reachability.pl

@@ -11,7 +11,7 @@ why(
         bindings([binding("Start", a), binding("Goal", f)]),
         uses([
           proof(
-            goal(reachable(a, f, "a")),
+            goal(reachable_via(a, f, "a")),
             by(rule("graph-reachability.pl", clause(9))),
             bindings([binding("Start", a), binding("Goal", f), binding("Visited", "a"), binding("Next", b)]),
             uses([
@@ -24,7 +24,7 @@ why(
                 by(builtin('\\+', 1))
               ),
               proof(
-                goal(reachable(b, f, "ba")),
+                goal(reachable_via(b, f, "ba")),
                 by(rule("graph-reachability.pl", clause(9))),
                 bindings([binding("Start", b), binding("Goal", f), binding("Visited", "ba"), binding("Next", d)]),
                 uses([
@@ -37,7 +37,7 @@ why(
                     by(builtin('\\+', 1))
                   ),
                   proof(
-                    goal(reachable(d, f, "dba")),
+                    goal(reachable_via(d, f, "dba")),
                     by(rule("graph-reachability.pl", clause(9))),
                     bindings([binding("Start", d), binding("Goal", f), binding("Visited", "dba"), binding("Next", f)]),
                     uses([
@@ -50,7 +50,7 @@ why(
                         by(builtin('\\+', 1))
                       ),
                       proof(
-                        goal(reachable(f, f, "fdba")),
+                        goal(reachable_via(f, f, "fdba")),
                         by(fact("graph-reachability.pl", clause(8))),
                         bindings([binding("Node", f), binding("_visited", "fdba")])
                       )
@@ -79,7 +79,7 @@ why(
         bindings([binding("Start", c), binding("Goal", g)]),
         uses([
           proof(
-            goal(reachable(c, g, "c")),
+            goal(reachable_via(c, g, "c")),
             by(rule("graph-reachability.pl", clause(9))),
             bindings([binding("Start", c), binding("Goal", g), binding("Visited", "c"), binding("Next", e)]),
             uses([
@@ -92,7 +92,7 @@ why(
                 by(builtin('\\+', 1))
               ),
               proof(
-                goal(reachable(e, g, "ec")),
+                goal(reachable_via(e, g, "ec")),
                 by(rule("graph-reachability.pl", clause(9))),
                 bindings([binding("Start", e), binding("Goal", g), binding("Visited", "ec"), binding("Next", f)]),
                 uses([
@@ -105,7 +105,7 @@ why(
                     by(builtin('\\+', 1))
                   ),
                   proof(
-                    goal(reachable(f, g, "fec")),
+                    goal(reachable_via(f, g, "fec")),
                     by(rule("graph-reachability.pl", clause(9))),
                     bindings([binding("Start", f), binding("Goal", g), binding("Visited", "fec"), binding("Next", g)]),
                     uses([
@@ -118,7 +118,7 @@ why(
                         by(builtin('\\+', 1))
                       ),
                       proof(
-                        goal(reachable(g, g, "gfec")),
+                        goal(reachable_via(g, g, "gfec")),
                         by(fact("graph-reachability.pl", clause(8))),
                         bindings([binding("Node", g), binding("_visited", "gfec")])
                       )

package/package.json

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

package/src/cli.js

@@ -196,6 +196,10 @@ export async function main(argv) {
   });
 
   const portabilityFailures = program.interopPortabilityWarnings ?? [];
+  // Shadowing is reported unconditionally: silently replacing a library
+  // predicate for the whole program is the failure mode this diagnostic exists
+  // to surface, so it must not depend on opting in to --warnings.
+  printLibraryShadowingWarnings(program);
   if (options.warnings || (options.portable && portabilityFailures.length > 0)) printWarnings(program);
   if (options.portable && portabilityFailures.length > 0) {
     process.exitCode = 1;
@@ -364,6 +368,14 @@ function printSourceWarning(warning) {
 `);
 }
 
+function printLibraryShadowingWarnings(program) {
+  for (const warning of program.libraryShadowingWarnings ?? []) {
+    process.stderr.write('eyeprolog warning: user definition shadows a bundled library predicate\n');
+    process.stderr.write(`  ${warning.indicator} replaces library(${warning.library}) ${warning.indicator} for all user code in this program\n`);
+    process.stderr.write(`  import it explicitly with :- use_module(library(${warning.library}), [${warning.indicator}]). to make this an error\n`);
+  }
+}
+
 function printWarnings(program) {
   for (const warning of program.interopPortabilityWarnings ?? []) {
     if (warning.kind === 'library') {

package/src/program.js

@@ -153,6 +153,7 @@ export class Program {
     this.autoloadedPredicates = [];
     this.libraryImports = [];
     this.interopPortabilityWarnings = [];
+    this.libraryShadowingWarnings = [];
     this.dynamicPredicates = new Set();
     // ISO 7.5.3 notes that a public/1 directive declaring user-defined
     // procedures to be public would be an extension. Such a procedure stays
@@ -1428,6 +1429,50 @@ function analyzeInteropPortability(program, extraGoals = []) {
     });
   }
   program.interopPortabilityWarnings = [...warnings.values()];
+  analyzeLibraryShadowing(program);
+}
+
+// A user-defined procedure replaces the bundled-library procedure of the same
+// name and arity: the library clauses are never autoloaded, so other parts of
+// the same program that expected the library behaviour just see the user's
+// clauses. Bundled library modules keep resolving their own internal calls, so
+// this only affects user code, but within user code it acts at a distance
+// across included files.
+//
+// How strictly this is treated depends on how explicit the program was, which
+// follows the graded scheme SWI-Prolog uses for the same situation:
+//
+//   implicit autoload                          -> warning
+//   use_module(library(L))                     -> warning
+//   use_module(library(L), [Name/Arity])       -> permission_error
+//
+// Only the last case is an outright contradiction: the program asked for that
+// exact predicate to be imported and then supplied clauses for it. The first
+// two stay warnings so that flat, module-free programs -- which load unchanged
+// on Scryer and Trealla, where the library is simply never imported -- keep
+// working. Note that ISO reserves permission_error(modify, static_procedure)
+// for built-in predicates (7.5.3); library predicates are not built-ins, so
+// this error is raised only where the program's own import list demands it.
+function analyzeLibraryShadowing(program) {
+  const explicitlyImported = new Map();
+  for (const entry of program.libraryImports) {
+    if (entry.imports == null) continue;
+    for (const indicator of entry.imports) {
+      explicitlyImported.set(`${entry.targetModule}:${indicator.key}`, entry.library);
+    }
+  }
+
+  const shadowed = new Map();
+  for (const group of program.groups.values()) {
+    if (group.module !== 'user') continue;
+    const key = `${group.name}/${group.arity}`;
+    const explicitLibrary = explicitlyImported.get(`${group.module}:${key}`);
+    if (explicitLibrary != null) throw staticProcedureModificationError(group.name, group.arity);
+    const library = eyePrologLibraryAutoload[key];
+    if (library == null || shadowed.has(key)) continue;
+    shadowed.set(key, { kind: 'shadowed-library-predicate', indicator: key, library });
+  }
+  program.libraryShadowingWarnings = [...shadowed.values()];
 }
 
 function sourceOptionsFor(source, options) {

package/test/conformance/ISO-PROLOG-TEXT-EXECUTION-MATRIX.md

@@ -23,7 +23,7 @@ chosen behavior is also indexed by `ISO-IMPLEMENTATION-DEFINED.md`.
 | 7.4.2.7 `include/1` | covered | The included text is prepared at the directive position and shares operator/character/flag preparation state with its parent. |
 | 7.4.2.8 `ensure_loaded/1` | covered | A source is prepared at most once in the current load graph, including repeated references and self/top-level references. |
 | 7.4.2.9 `set_prolog_flag/2` | covered | Preparation-time flag changes affect subsequent text and are replayed into execution state; strict flag names/values/changeability remain governed by the closed 7.11 review. |
-| 7.4.3 source clauses | covered | Source heads/bodies are validated like program clauses, standardized static/control procedures are protected, declarations can create empty procedures, and body conversion follows 7.6.2 while preserving head/body variable identity. The built-in restriction applies in every execution mode, so consulting a clause for a built-in predicate or control construct reports the same `permission_error(modify, static_procedure)` as `assert`ing one; EyeProlog's own library and extension predicates are not standard built-ins and stay redefinable. Corpus: `error/iso/consult_redefines_builtin`. |
+| 7.4.3 source clauses | covered | Source heads/bodies are validated like program clauses, standardized static/control procedures are protected, declarations can create empty procedures, and body conversion follows 7.6.2 while preserving head/body variable identity. The built-in restriction applies in every execution mode, so consulting a clause for a built-in predicate or control construct reports the same `permission_error(modify, static_procedure)` as `assert`ing one; EyeProlog's own library and extension predicates are not standard built-ins, so ISO does not protect them. They stay redefinable when they reach the program implicitly, through autoloading or a whole-module `use_module(library(L))`, but the redefinition is reported as a shadowing warning because it replaces the library predicate for all user code in the program. Naming a predicate in an explicit import list, `use_module(library(L), [Name/Arity])`, and then supplying clauses for it is a contradiction and reports `permission_error(modify, static_procedure)`. Bundled library modules keep resolving their own internal calls, so a user redefinition never changes library behaviour. Corpus: `error/iso/consult_redefines_builtin`. |
 
 The strict release test `closes ISO 7.4 Prolog-text preparation and directive
 rows` exercises the cross-text operator/character/flag state, include and