eyeprolog 1.3.69 → 1.3.71

package/src/program.js

@@ -576,8 +576,16 @@ class ProgramBuilder {
       targetSet.add(key);
       declaredMap.set(`${textUnit}\u0000${key}`, { ...indicator, key, module, textUnit });
       if (kind === 'dynamic') {
-        const existing = program.groups.get(key);
-        if (existing) existing.dynamic = true;
+        // A dynamic declaration creates the procedure immediately, not only
+        // when ProgramBuilder.finish() runs. Compile-time source-expansion
+        // hooks can therefore call an explicitly declared empty dynamic
+        // predicate while the remainder of the same file is still loading.
+        let existing = program.groups.get(key);
+        if (!existing) {
+          existing = program.makeGroup(indicator.name, indicator.arity, module);
+          program.groups.set(key, existing);
+        }
+        existing.dynamic = true;
       }
     }
     return true;
@@ -1065,6 +1073,7 @@ function sourcePath(options) {
 
 function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules, fast, context) {
   const batch = [];
+  const deferredGoalExpansions = [];
   const flush = () => {
     if (batch.length === 0) return;
     builder.addClauses(batch);
@@ -1114,10 +1123,23 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
     clause = normalizeQualifiedClauseHead(clause, lexicalModule);
 
     if (!builder.program.strictIso && !isDirectiveClause(clause)) {
-      expandClauseGoals(builder.program, clause, lexicalModule, {
-        module: lexicalModule,
-        filename: options.filename ?? '<input>',
-      });
+      try {
+        expandClauseGoals(builder.program, clause, lexicalModule, {
+          module: lexicalModule,
+          filename: options.filename ?? '<input>',
+        });
+      } catch (error) {
+        // Scryer-compatible goal-expansion hooks may refer to helper predicates
+        // that occur later in the same source file. Keep loading so those
+        // helpers become visible, then retry this clause at end-of-source.
+        // A still-missing helper (or any other expansion error) is reported on
+        // the final retry rather than being silently ignored.
+        if (!(error instanceof PrologError) || error.formal !== 'existence_error(procedure)') throw error;
+        clause.module ??= lexicalModule;
+        clause.textUnit ??= context.textUnit;
+        deferredGoalExpansions.push({ clause, lexicalModule });
+        return;
+      }
     }
 
     const moduleDeclaration = moduleDirective(clause);
@@ -1207,6 +1229,16 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
   }
   parseClausesInto(source, options, processClause);
   flush();
+  if (!builder.program.strictIso && deferredGoalExpansions.length > 0) {
+    for (const { clause, lexicalModule } of deferredGoalExpansions) {
+      expandClauseGoals(builder.program, clause, lexicalModule, {
+        module: lexicalModule,
+        filename: options.filename ?? '<input>',
+      });
+      for (const goal of clause.body) annotateGoalModule(goal, clause.lexicalModule ?? lexicalModule);
+      builder.addClauses([clause]);
+    }
+  }
   return true;
 }
 

package/src/solver.js

@@ -10,7 +10,6 @@ import { PrologError, getStrictIsoRegistry } from './iso.js';
 import { getEyePrologRegistry } from './standard-library.js';
 import { selectClauseCandidates, selectClauseCandidatesForValues, selectGroundClauseCandidates } from './program-indexing.js';
 import { StreamManager } from './io.js';
-import { clpzStateConsistent } from './clpz.js';
 import { hardHeapLimit, softHeapLimit, usedHeapSize } from './platform.js';
 import { evaluateWfs, relationForGroup, truthOfGroundGoal } from './wfs.js';
 import { ISO_MAX_ARITY } from './iso-limits.js';
@@ -428,6 +427,45 @@ export class Solver {
         });
         continue;
       }
+      if (frame.kind === 'userClause') {
+        if (this.solutionsSeen >= this.solutionLimit) continue;
+        const { clause, goal: clauseGoal, rest: clauseRest, env: clauseEnv, depth: clauseDepth,
+          active: clauseActive, release } = frame;
+        let next;
+        if (clause.body.length === 0 && clause.scalarHead) {
+          next = matchScalarFact(clauseGoal, clause.head, clauseEnv);
+          if (!next) continue;
+          this.stats.unify_calls++;
+          stack.push({
+            kind: 'goals',
+            goals: [...release, ...clauseRest],
+            env: next,
+            depth: clauseDepth + 1,
+            active: clauseActive,
+          });
+          continue;
+        }
+        const id = nextFreshId();
+        const freshVariables = new Map();
+        const freshHead = freshTerm(clause.head, id, freshVariables);
+        const freshBody = clause.body.map((term) => freshTerm(term, id, freshVariables));
+        const localFreshPlan = clauseLocalFreshPlan(clause);
+        const headLocalFresh = freshVariableSet(localFreshPlan.head, freshVariables);
+        attachBodyLocalFreshVariables(freshBody, localFreshPlan.body, freshVariables);
+        next = clauseEnv.clone();
+        this.stats.unify_calls++;
+        if (!unify(clauseGoal, freshHead, next, { knownNonoccurringVariables: headLocalFresh })) continue;
+        stack.push({
+          kind: 'goals',
+          goals: freshBody.length === 0
+            ? [...release, ...clauseRest]
+            : [...freshBody, ...release, ...clauseRest],
+          env: next,
+          depth: clauseDepth + 1,
+          active: clauseActive,
+        });
+        continue;
+      }
       if (frame.kind === 'completeTableFixpointRound') {
         if (frame.revision !== this.programRevision) continue;
         frame.entry.computing = false;
@@ -491,7 +529,6 @@ export class Solver {
         }
 
         if (goals.length === 0) {
-          if (!clpzStateConsistent(env)) break;
           this.solutionsSeen++;
           this.stats.completed_goal_lists++;
           this.active = active;
@@ -1182,53 +1219,27 @@ function pushUserGoalUncachedFrames(stack, solver, group, goal, rest, env, depth
   for (const pass of [candidates.primary, candidates.fallback]) {
     for (let candidateIndex = 0; candidateIndex < clauseCandidateLength(pass); candidateIndex++) {
       const clause = clauseCandidateAt(pass, candidateIndex);
-      if (clause.body.length === 0 && clause.scalarHead) {
-        const next = matchScalarFact(goal, clause.head, env);
-        if (next) {
-          solver.stats.unify_calls++;
-          frames.push({
-            kind: 'goals',
-            goals: [...release, ...rest],
-            env: next,
-            depth: depth + 1,
-            active: nextActive,
-          });
-        }
-        continue;
-      }
       if (headCannotMatch(goal, clause.head, env)) continue;
-      const id = nextFreshId();
-      const freshVariables = new Map();
-      const freshHead = freshTerm(clause.head, id, freshVariables);
-      const freshBody = clause.body.map((term) => freshTerm(term, id, freshVariables));
-      const localFreshPlan = clauseLocalFreshPlan(clause);
-      const headLocalFresh = freshVariableSet(localFreshPlan.head, freshVariables);
-      attachBodyLocalFreshVariables(freshBody, localFreshPlan.body, freshVariables);
-      const next = env.clone();
-      solver.stats.unify_calls++;
-      if (!unify(goal, freshHead, next, { knownNonoccurringVariables: headLocalFresh })) continue;
-      if (freshBody.length === 0) {
-        frames.push({
-          kind: 'goals',
-          goals: [...release, ...rest],
-          env: next,
-          depth: depth + 1,
-          active: nextActive,
-        });
-      } else {
-        frames.push({
-          kind: 'goals',
-          goals: [...freshBody, ...release, ...rest],
-          env: next,
-          depth: depth + 1,
-          active: nextActive,
-        });
-      }
+      // Do not speculatively unify alternative heads. With attributed variables,
+      // head unification can run verify_attributes/3, queue wakeups, fail, or
+      // throw. Those effects are observable and must occur only if Prolog search
+      // actually reaches this clause (in particular after earlier cuts).
+      frames.push({
+        kind: 'userClause',
+        clause,
+        goal,
+        rest,
+        env,
+        depth,
+        active: nextActive,
+        release,
+      });
     }
   }
   for (let i = frames.length - 1; i >= 0; i--) stack.push(frames[i]);
 }
 
+
 function clauseLocalFreshPlan(clause) {
   if (clause._localFreshPlan != null) return clause._localFreshPlan;
   const seen = new Set();
@@ -1273,19 +1284,7 @@ function attachBodyLocalFreshVariables(freshBody, plan, freshVariables) {
     if (knownNonoccurringVariables == null || goal?.type !== COMPOUND) continue;
     if (goal.name === '=' && goal.arity === 2) {
       goal._knownNonoccurringVariables = knownNonoccurringVariables;
-      continue;
-    }
-    // Only a compiler-generated DCG state first handed as a complete argument
-    // to another callable receives a longer-lived local marker. Equality-created
-    // sequence variables keep the existing one-unification proof instead.
-    const localFirstUseVariables = new Set();
-    for (const argument of goal.args) {
-      if (argument?.type === VAR && argument.name.startsWith('\u0000dcg') &&
-          knownNonoccurringVariables.has(argument.name)) {
-        localFirstUseVariables.add(argument.name);
-      }
     }
-    if (localFirstUseVariables.size !== 0) goal._localFirstUseVariables = localFirstUseVariables;
   }
 }
 
@@ -1538,7 +1537,7 @@ function bundledLengthIterator(solver, group, goal, env) {
 
   // Delayed and constrained variables need the ordinary solver's wake-up
   // points. The fast path is deliberately limited to plain finite-tree terms.
-  if (env._clpz != null) return null;
+  if (env._prologAttributes != null) return null;
   const length = deref(goal.args[1], env);
   if (length.type === VAR && env._delays?.has(length.name)) return null;
 
@@ -2043,7 +2042,7 @@ function fastCountBranch(branch, env) {
 
 function fastCountPureGoal(solver, goal, env) {
   if (solver.isoStrict || solver.solutionLimit !== Infinity || solver.maxInferences !== Infinity ||
-      env._clpz != null || env._variableConstraints != null || env._prologAttributes != null || (env._delays != null && env._delays.size !== 0)) return null;
+      env._variableConstraints != null || env._prologAttributes != null || (env._delays != null && env._delays.size !== 0)) return null;
   const budget = { remaining: 8192 };
   const branches = expandPureCountGoal(solver, goal, goal.module ?? 'user', new Set(), budget);
   if (branches == null) return null;
@@ -2681,7 +2680,8 @@ function activeVariantIn(goal, env, active) {
     // Variant calls must have the same predicate indicator. Avoid walking
     // large matrix/list arguments for every unrelated active predicate.
     if (candidate?.type !== goal.type || candidate?.name !== goal.name ||
-        candidate?.arity !== goal.arity) continue;
+        candidate?.arity !== goal.arity ||
+        (candidate?.module ?? 'user') !== (goal.module ?? 'user')) continue;
     goalShape ??= variantShape(goal, env);
     entry.variantShape ??= variantShape(candidate, entry.env);
     if (goalShape !== entry.variantShape) continue;

package/src/source-expansion.js

@@ -71,7 +71,7 @@ function runHook(program, module, name, input, loadContext = null) {
     const goal = compound(name, [input, output]);
     goal.module = owner;
     const solver = new Solver(program, {
-      solutionLimit: 1,
+      solutionLimit: Infinity,
       maxInferences: MAX_EXPANSION_INFERENCES,
       sourceLoadContext: loadContext,
     });

package/src/standard-library.js

@@ -3,7 +3,6 @@
 // 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 { attsBuiltins } from './atts.js';
 import { expansionBuiltins } from './expansion-builtins.js';
 import { scryerCompatibilityBuiltins } from './scryer-compat.js';
@@ -203,7 +202,6 @@ export function createEyePrologRegistry() {
   attsBuiltins.register(registry);
   expansionBuiltins.register(registry);
   scryerCompatibilityBuiltins.register(registry);
-  clpzBuiltins.register(registry);
   registry.eyePrologLibrary = true;
   return registry;
 }

package/src/term.js

@@ -112,7 +112,6 @@ export class Env {
     // Backtrackable blackboard entries used by Scryer-compatible libraries.
     // Values are logical terms and the map is copy-on-write across Env clones.
     this._backtrackableBlackboard = null;
-    this._clpz = null;
     this._occursCheckHandler = null;
     this._localVariables = null;
   }
@@ -131,7 +130,6 @@ export class Env {
     clone._attributeHookRunner = this._attributeHookRunner;
     clone._pendingAttributeGoals = this._pendingAttributeGoals;
     clone._backtrackableBlackboard = this._backtrackableBlackboard;
-    clone._clpz = this._clpz;
     clone._occursCheckHandler = this._occursCheckHandler;
     clone._localVariables = this._localVariables;
     return clone;
@@ -153,7 +151,6 @@ export class Env {
     this._prologAttributes = other._prologAttributes;
     this._pendingAttributeGoals = other._pendingAttributeGoals;
     this._backtrackableBlackboard = other._backtrackableBlackboard;
-    this._clpz = other._clpz;
     // Execution callbacks belong to the Solver driving this Env, not to the
     // logical branch being adopted from an inner attribute-hook call.
     this._localVariables = other._localVariables;

package/src/write.js

@@ -86,7 +86,12 @@ function isWordOperatorToken(token) {
 
 function compactPrefixOperator(token, argument) {
   if (isWordOperatorToken(token)) return `${token} ${argument}`;
-  return `${token}${compactBoundaryNeedsSpace(token, argument) ? ' ' : ''}${argument}`;
+  // Without layout, `op(...)` is functional notation rather than prefix-operator
+  // notation. ISO 7.10.5 h requires operator-form output and layout whenever
+  // ambiguity could otherwise arise, so a parenthesized prefix argument must
+  // never be glued directly to the operator token.
+  const needsLayout = argument.startsWith('(') || compactBoundaryNeedsSpace(token, argument);
+  return `${token}${needsLayout ? ' ' : ''}${argument}`;
 }
 
 function compactPostfixOperator(argument, token) {
@@ -188,28 +193,6 @@ function chooseOperator(term, table) {
   return null;
 }
 
-function startsWithUnsignedNumber(term, env, table, options) {
-  const resolved = deref(term, env);
-  if (resolved.type === NUMBER) return !resolved.name.startsWith('-');
-  if (resolved.type !== COMPOUND || isCons(resolved)) return false;
-  if (options.numbervars && resolved.name === '$VAR' && resolved.arity === 1) {
-    const index = deref(resolved.args[0], env);
-    if (index.type === NUMBER && /^\d+$/.test(index.name) &&
-        writeNumberedVariable(Number(index.name)) != null) {
-      return false;
-    }
-  }
-  const definition = chooseOperator(resolved, table);
-  if (definition == null) return false;
-  if (definition.specifier === 'xf' || definition.specifier === 'yf') {
-    return startsWithUnsignedNumber(resolved.args[0], env, table, options);
-  }
-  if (definition.specifier === 'xfx' || definition.specifier === 'xfy' || definition.specifier === 'yfx') {
-    return startsWithUnsignedNumber(resolved.args[0], env, table, options);
-  }
-  return false;
-}
-
 function printableReadVariableNames(term, env, explicit) {
   const names = new Map(explicit);
   const used = new Set(names.values());
@@ -353,13 +336,30 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
       let text;
       if (specifier === 'fx' || specifier === 'fy') {
         const argumentPriority = specifier === 'fx' ? priority - 1 : priority;
-        // A separated `- 1` is still read as the negative number -1.  When
-        // the source term is the unary -/1 compound, parenthesize a positive
-        // numeric-leading argument so writeq/write_term remain read-back safe
-        // (WG17 #135, #183, #215, #216, and #248).
-        if (resolved.name === '-' && startsWithUnsignedNumber(resolved.args[0], env, table, options)) {
+        // Corrigendum 3 adds mandatory parentheses for prefix - when its
+        // argument is a non-negative number or is written in infix/postfix
+        // operator form (ISO 7.10.5 h 2(iii-iv)).
+        const child = deref(resolved.args[0], env);
+        const childNumbervar = options.numbervars && child.type === COMPOUND &&
+          child.name === '$VAR' && child.arity === 1 && (() => {
+            const index = deref(child.args[0], env);
+            return index.type === NUMBER && /^\d+$/.test(index.name) &&
+              writeNumberedVariable(Number(index.name)) != null;
+          })();
+        const childUsesSpecialNotation = isCons(child) ||
+          (child.type === COMPOUND && child.name === '{}' && child.arity === 1) || childNumbervar;
+        const childDefinition = childUsesSpecialNotation ? null : chooseOperator(child, table);
+        const negativeNeedsParentheses = resolved.name === '-' && (
+          (child.type === NUMBER && !child.name.startsWith('-')) ||
+          ['xf', 'yf', 'xfx', 'xfy', 'yfx'].includes(childDefinition?.specifier)
+        );
+        if (negativeNeedsParentheses) {
+          // ISO 7.10.5 h 2(iii-iv): prefix - requires parentheses around a
+          // non-negative number and around an argument written in infix or
+          // postfix operator form. Keep layout before `(` so the result is
+          // operator notation, not functional notation such as `-(...)`.
           const argument = format(resolved.args[0], env, options, table, 1200);
-          text = options.minimalOperatorSpacing ? `${token}(${argument})` : `${token} (${argument})`;
+          text = `${token} (${argument})`;
         } else {
           const argument = format(resolved.args[0], env, options, table, argumentPriority);
           text = options.minimalOperatorSpacing ? compactPrefixOperator(token, argument) : `${token} ${argument}`;

package/test/conformance/WG17-SYNTAX-STATUS.md

@@ -11,10 +11,14 @@ upstream assertion.
 
 ## Current standing
 
+The percentage below is **traceability coverage**, not a conformance pass rate.
+A represented case still has to pass the executable upstream assertion in
+`test/run-wg17.mjs`.
+
 | Measure | Count |
 | --- | ---: |
 | Active upstream cases | 366 |
-| Executable EyeProlog dispositions | 366 (100.0%) |
+| Upstream cases represented in the executable matrix | 366 (100.0%) |
 | Not yet traced one-by-one | 0 |
 | Deleted upstream identifiers | #20, #273 |