eyeprolog 1.5.60 → 1.5.62

package/package.json

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

package/src/errors.js

@@ -33,8 +33,14 @@ function builtinErrorContext(def, goal) {
     // A one-element list, not a bare indicator: error contexts are lists so
     // that library(error)'s call_with_error_context/2 can prepend its own
     // elements and still yield a proper list (issue #98).
+    // A one-element list holding a predicate-F/A pair: contexts are lists so
+    // call_with_error_context/2 can prepend, and elements are pairs so the
+    // convention is uniform with library-supplied elements (issues #98, #99).
     context = compound('.', [
-      compound('/', [atom(goal.name), numberTerm(goal.arity)]),
+      compound('-', [
+        atom('predicate'),
+        compound('/', [atom(goal.name), numberTerm(goal.arity)]),
+      ]),
       emptyList(),
     ]);
     def._errorContextTerm = context;

package/src/lib/error.pl

@@ -21,34 +21,39 @@
 %  raise site: the raise sites throw with [] and this wrapper prepends its
 %  element, so contexts stay proper lists and compose with any enclosing
 %  call_with_error_context/2 (issue #98).
+%  The context is named in exactly one place -- error__must_be_throw/1 -- so no
+%  raise site hands one over (issue #98). It is a throw helper rather than a
+%  call_with_error_context/2 wrapper because wrapping a Prolog goal in catch/3
+%  costs a child Solver on every call, and must_be/2 succeeds almost always.
 must_be(Type, Term) :-
-    call_with_error_context(
-        ( var(Type) -> instantiation_error
-        ; error__must_be(Type, Term)
-        ),
-        must_be/2).
+    ( var(Type) -> error__must_be_throw(instantiation_error)
+    ; error__must_be(Type, Term)
+    ).
+
+error__must_be_throw(Formal) :-
+    throw(error(Formal, [predicate-must_be/2])).
 
 error__must_be(integer, Term) :- !,
-    ( var(Term) -> instantiation_error
+    ( var(Term) -> error__must_be_throw(instantiation_error)
     ; integer(Term) -> true
-    ; type_error(integer, Term)
+    ; error__must_be_throw(type_error(integer, Term))
     ).
 error__must_be(atom, Term) :- !,
-    ( var(Term) -> instantiation_error
+    ( var(Term) -> error__must_be_throw(instantiation_error)
     ; atom(Term) -> true
-    ; type_error(atom, Term)
+    ; error__must_be_throw(type_error(atom, Term))
     ).
 error__must_be(number, Term) :- !,
-    ( var(Term) -> instantiation_error
+    ( var(Term) -> error__must_be_throw(instantiation_error)
     ; number(Term) -> true
-    ; type_error(number, Term)
+    ; error__must_be_throw(type_error(number, Term))
     ).
 error__must_be(var, Term) :- !,
     ( var(Term) -> true
     ; throw(error(uninstantiation_error(Term), []))
     ).
 error__must_be(ground, Term) :- !,
-    ( ground(Term) -> true ; instantiation_error ).
+    ( ground(Term) -> true ; error__must_be_throw(instantiation_error) ).
 error__must_be(acyclic, Term) :- !,
     ( acyclic_term(Term) -> true ; type_error(acyclic_term, Term) ).
 error__must_be(list, Term) :- !,
@@ -56,23 +61,23 @@ error__must_be(list, Term) :- !,
 error__must_be(list(Type), Term) :- !,
     error__proper_list_of(Term, Type).
 error__must_be(pair, Term) :- !,
-    ( var(Term) -> instantiation_error
+    ( var(Term) -> error__must_be_throw(instantiation_error)
     ; Term = _-_ -> true
-    ; type_error(pair, Term)
+    ; error__must_be_throw(type_error(pair, Term))
     ).
 error__must_be(not_less_than_zero, Term) :- !,
     must_be(integer, Term),
     ( Term >= 0 -> true ; domain_error(not_less_than_zero, Term) ).
 error__must_be(Type, Term) :-
-    ( var(Term) -> instantiation_error
-    ; type_error(Type, Term)
+    ( var(Term) -> error__must_be_throw(instantiation_error)
+    ; error__must_be_throw(type_error(Type, Term))
     ).
 
 error__proper_list([]) :- !.
 error__proper_list([_|Tail]) :- !, error__proper_list(Tail).
 error__proper_list(Term) :-
-    ( var(Term) -> instantiation_error
-    ; type_error(list, Term)
+    ( var(Term) -> error__must_be_throw(instantiation_error)
+    ; error__must_be_throw(type_error(list, Term))
     ).
 
 error__proper_list_of([], _) :- !.
@@ -80,7 +85,7 @@ error__proper_list_of([Head|Tail], Type) :- !,
     must_be(Type, Head),
     error__proper_list_of(Tail, Type).
 error__proper_list_of(Term, _) :-
-    ( var(Term) -> instantiation_error
+    ( var(Term) -> error__must_be_throw(instantiation_error)
     ; type_error(list, Term)
     ).
 
@@ -132,7 +137,18 @@ resource_error(Resource, Context) :- throw(error(resource_error(Resource), Conte
 %  free, though: see issue #98 for measurements and the primitive design that
 %  would remove it.
 call_with_error_context(Goal, Pair) :-
+    error__require_pair(Pair),
     catch(Goal,
           error(Error, Context),
           ( copy_term(Pair, Element),
             throw(error(Error, [Element|Context])) )).
+
+%  The element must be a pair (issue #99). This cannot go through must_be/2:
+%  must_be/2 declares its own context with call_with_error_context/2, so
+%  checking with must_be/2 here would recurse. The reported context matches
+%  what must_be(pair, _) would have produced.
+error__require_pair(Pair) :-
+    ( var(Pair) -> throw(error(instantiation_error, [predicate-must_be/2]))
+    ; Pair = _-_ -> true
+    ; throw(error(type_error(pair, Pair), [predicate-must_be/2]))
+    ).

package/src/lib/random.pl

@@ -10,7 +10,7 @@
 :- module(random, [maybe/0, maybe/1, maybe/2, random/1, random/3, random_integer/3, set_random/1]).
 
 :- use_module(library(iso_ext), [bb_get/2, bb_put/2]).
-:- use_module(library(error), [call_with_error_context/2, instantiation_error/0, type_error/2]).
+
 
 maybe :-
     random_integer(0, 2, 0).
@@ -31,7 +31,7 @@ random(Value) :-
 %  Context declared once per predicate instead of at each raise site, so the
 %  raise sites throw with [] and contexts stay proper composable lists.
 random_integer(Lower, Upper, R) :-
-    call_with_error_context(random__check_integer_range(Lower, Upper), random_integer/3),
+    random__check_integer_range(Lower, Upper),
     Lower < Upper,
     random__current_seed(Seed0),
     random(Seed0, _, Seed),
@@ -39,28 +39,31 @@ random_integer(Lower, Upper, R) :-
     R is Lower + Seed mod (Upper - Lower).
 
 set_random(Seed) :-
-    call_with_error_context(random__set_seed(Seed), set_random/1).
+    random__set_seed(Seed).
+
+random__throw(Formal, Predicate) :-
+    throw(error(Formal, [predicate-Predicate])).
 
 random__check_integer_range(Lower, Upper) :-
-    ( var(Lower) -> instantiation_error
-    ; var(Upper) -> instantiation_error
+    ( var(Lower) -> random__throw(instantiation_error, random_integer/3)
+    ; var(Upper) -> random__throw(instantiation_error, random_integer/3)
     ; integer(Lower) -> true
-    ; type_error(integer, Lower)
+    ; random__throw(type_error(integer, Lower), random_integer/3)
     ),
     ( integer(Upper) -> true
-    ; type_error(integer, Upper)
+    ; random__throw(type_error(integer, Upper), random_integer/3)
     ).
 
 random__set_seed(Seed) :-
-    ( var(Seed) -> instantiation_error
+    ( var(Seed) -> random__throw(instantiation_error, set_random/1)
     ; Seed = seed(S) ->
-        ( var(S) -> instantiation_error
+        ( var(S) -> random__throw(instantiation_error, set_random/1)
         ; integer(S) ->
             random__random_normalize_seed(S, Normalized),
             bb_put('$random_seed', Normalized)
-        ; type_error(integer, S)
+        ; random__throw(type_error(integer, S), set_random/1)
         )
-    ; type_error(random_state, Seed)
+    ; random__throw(type_error(random_state, Seed), set_random/1)
     ).
 
 random__current_seed(Seed) :- bb_get('$random_seed', Seed), !.

package/test/conformance/ISO-IMPLEMENTATION-DEFINED.md

@@ -67,7 +67,7 @@ Status values are:
 | 7.11.2.2 | Effect when `debug=on` | The flag is accepted and stored; it does not change goal semantics or enable a debugger. | **defined** — `src/solver.js`; no semantic branch depends on `debug`. |
 | 7.11.2.3 | Default `max_arity` | `unbounded`: EyeProlog imposes no fixed semantic ceiling on compound-term arity. Practical host allocation exhaustion is a resource condition. This flag is distinct from any potential implementation-specific procedure-arity limit; EyeProlog currently declares no separate finite procedure limit. | **defined** — `src/iso-limits.js`, `src/solver.js`, `src/parser.js`, `src/iso.js`; strict regression coverage. |
 | 7.11.2.5 | Default `double_quotes` | `chars`. | **defined** — `src/solver.js`, parser flag state. |
-| 7.12.1 | Second argument of `error/2` | A list of context elements, innermost last. A built-in contributes its own predicate indicator, so `atom_length(1.0, _)` raises `error(type_error(atom, 1.0), [atom_length/2])`. Errors raised outside a built-in frame, and errors thrown from shared pre-built instances reused by several built-ins, use `[]`. Each enclosing `call_with_error_context/2` prepends a copy of its own element, so contexts compose into proper lists. | **defined** — `attachBuiltinErrorContext()` in `src/errors.js`, `formalErrorTerm()` in `src/iso.js`, `call_with_error_context/2` in `src/lib/error.pl`. |
+| 7.12.1 | Second argument of `error/2` | A list of context elements, innermost last. Elements are pairs; a built-in contributes `predicate-F/A`, so `atom_length(1.0, _)` raises `error(type_error(atom, 1.0), [predicate-atom_length/2])`. Errors raised outside a built-in frame, and errors thrown from shared pre-built instances reused by several built-ins, use `[]`. Each enclosing `call_with_error_context/2` prepends a copy of its own element, so contexts compose into proper lists. | **defined** — `attachBuiltinErrorContext()` in `src/errors.js`, `formalErrorTerm()` in `src/iso.js`, `call_with_error_context/2` in `src/lib/error.pl`. |
 | 7.12.2(f) | Implementation-defined representation limits | Character and character-code operations are limited to Unicode scalar values; surrogates and values above U+10FFFF are representation errors. Arity/integer values are modeled as unbounded but may hit host/resource limits. Float input overflow uses the implementation-specific `max_float`/`min_float` representation names documented by the STC-oriented tests. | **defined** — parser/ISO numeric and character guards. |
 | 8.17.1 | Implementation-defined flag value ranges | Strict mode exposes only Part 1 core flags and their standard value sets. Normal mode additionally exposes EyeProlog's `occurs_check` and `default_procedure_access` flags. With `bounded=false`, `max_integer` and `min_integer` have no current or selectable value and their `current_prolog_flag/2` queries fail. Valid alternative values of fixed standard flags are distinguished from invalid values so `set_prolog_flag/2` reports permission versus domain errors as prescribed. | **defined** — strict registry/flag filtering in `src/solver.js`; strict flag tests. |
 | 8.17.3 | Other effects of `halt/0` | Terminates EyeProlog execution and returns host/process status `0`; it produces no Prolog solution. | **defined** — `HaltSignal`, `haltBuiltin()`, CLI/runner handling. |

package/test/conformance/expected/iso/exceptions_and_flags.pl

@@ -1,3 +1,3 @@
-answer(7, red, caught([atom_length / 2]), first, caught([])).
-answer(7, red, caught([atom_length / 2]), second, caught([])).
+answer(7, red, caught([predicate - atom_length / 2]), first, caught([])).
+answer(7, red, caught([predicate - atom_length / 2]), second, caught([])).
 flags(off, on, [pair(bounded, false), pair(integer_rounding_function, toward_zero), pair(char_conversion, on), pair(debug, off), pair(max_arity, unbounded), pair(unknown, fail), pair(double_quotes, chars), pair(occurs_check, true), pair(default_procedure_access, private)]).

package/test/regression/cases-regression.mjs

@@ -1891,7 +1891,7 @@ c4 ?- call((!;1)).
         assertIncludes(repl.stdout, 'T = ./*. .', 'REPL dotted graphic atom answer');
         assertNotIncludes(repl.stdout, "T = './*.'", 'REPL dotted graphic atom has no spurious quotes');
         assertIncludes(repl.stdout, 'T = ok.', 'REPL following read answer');
-        assertIncludes(repl.stdout, 'error(syntax_error(read_term), [read/1])', 'REPL syntax error');
+        assertIncludes(repl.stdout, 'error(syntax_error(read_term), [predicate-read/1])', 'REPL syntax error');
         assertEqual(repl.stderr, '', 'REPL stderr');
 
         const continuedGraphic = runCli([], {
@@ -2719,8 +2719,8 @@ c4 ?- call((!;1)).
         });
         assertEqual(result.status, 0, 'exit status');
         assertEqual(result.stdout,
-          '?-    error(type_error(list, [1, [], _A | 2]), [number_chars/2]).\n' +
-          '?-    error(type_error(list, [1, [], _A | 2]), [number_chars/2]).\n' +
+          '?-    error(type_error(list, [1, [], _A | 2]), [predicate-number_chars/2]).\n' +
+          '?-    error(type_error(list, [1, [], _A | 2]), [predicate-number_chars/2]).\n' +
           '?- ',
           'stdout');
         assertEqual(result.stderr, '', 'stderr');
@@ -2734,8 +2734,8 @@ c4 ?- call((!;1)).
         });
         assertEqual(result.status, 0, 'exit status');
         assertEqual(result.stdout,
-          '?-    error(instantiation_error, [(is)/2]).\n' +
-          '?-    Error = instantiation_error, Imp_def = [(is)/2].\n' +
+          '?-    error(instantiation_error, [predicate-(is)/2]).\n' +
+          '?-    Error = instantiation_error, Imp_def = [predicate-(is)/2].\n' +
           '?- ',
           'stdout');
         assertEqual(result.stderr, '', 'stderr');
@@ -4044,7 +4044,7 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
         const result = runCli([], { input: 'statistics(nonsense, Value).\nhalt.\n' });
         assertEqual(result.status, 0, 'exit status');
         assertIncludes(result.stdout,
-          'error(domain_error(statistics_key, nonsense), [statistics/2]).',
+          'error(domain_error(statistics_key, nonsense), [predicate-statistics/2]).',
           'statistics key error');
         assertEqual(result.stderr, '', 'stderr');
       },
@@ -4473,7 +4473,7 @@ answer(Result) :- countdown(2048, Result), Result = 2048.
           'answer(C) :- catch(call_with_error_context(atom_length(1.0,_), outer-1), error(_,C), true).\n';
         const result = runCli(['-'], { input });
         assertEqual(result.status, 0, `exit status; stderr=${result.stderr}`);
-        assertIncludes(result.stdout, 'answer([outer - 1, atom_length / 2])', 'composed context');
+        assertIncludes(result.stdout, 'answer([outer - 1, predicate - atom_length / 2])', 'composed context');
       },
     },
     {
@@ -4487,13 +4487,13 @@ answer(Result) :- countdown(2048, Result), Result = 2048.
           'answer(C) :- catch(must_be(integer, a), error(_,C), true).\n';
         const result = runCli(['-'], { input });
         assertEqual(result.status, 0, `exit status; stderr=${result.stderr}`);
-        assertIncludes(result.stdout, 'answer([must_be / 2])', 'must_be context is a list');
+        assertIncludes(result.stdout, 'answer([predicate - must_be / 2])', 'must_be context is a list');
 
         const composed = ':- use_module(library(error)).\n%% goal: answer(X)\n' +
           'answer(C) :- catch(call_with_error_context(must_be(integer, a), outer-1), error(_,C), true).\n';
         const nested = runCli(['-'], { input: composed });
         assertEqual(nested.status, 0, `nested exit status; stderr=${nested.stderr}`);
-        assertIncludes(nested.stdout, 'answer([outer - 1, must_be / 2])', 'composes as a proper list');
+        assertIncludes(nested.stdout, 'answer([outer - 1, predicate - must_be / 2])', 'composes as a proper list');
       },
     },
     {
@@ -4505,11 +4505,51 @@ answer(Result) :- countdown(2048, Result), Result = 2048.
         const repl = runCli([], {
           input: 'must_be(integer, a).\nthrow(foo).\nhalt.\n',
         });
-        assertIncludes(repl.stdout, 'error(type_error(integer, a), [must_be/2])', 'thrown ISO error');
+        assertIncludes(repl.stdout, 'error(type_error(integer, a), [predicate-must_be/2])', 'thrown ISO error');
         assertNotIncludes(repl.stdout, 'throw(error(type_error', 'no throw/1 wrapper on error/2');
         assertIncludes(repl.stdout, 'throw(foo)', 'non-error ball keeps the wrapper');
       },
     },
+    {
+      // must_be/2 is called constantly by library code, so its context must be
+      // supplied without a catch/3 frame: wrapping a Prolog goal in catch/3
+      // costs a child Solver per call and made the suite ~35% slower.
+      name: 'must_be/2 does not pay for a catch frame on success',
+      run: () => {
+        const input = '%% goal: answer(X)\n' +
+          'loop(0) :- !.\nloop(N) :- must_be(integer, N), M is N - 1, loop(M).\n' +
+          'answer(ok) :- loop(20000).\n';
+        const started = Date.now();
+        const result = runCli(['-'], { input });
+        const elapsed = Date.now() - started;
+        assertEqual(result.status, 0, `exit status; stderr=${result.stderr}`);
+        assertIncludes(result.stdout, 'answer(ok)', 'loop completes');
+        // Generous bound: the catch/3 wrapper made this roughly 2x slower.
+        if (elapsed >= 20000) throw new Error(`20k must_be/2 calls took ${elapsed}ms`);
+      },
+    },
+    {
+      // Issue #99: the context element must be a pair, as in Scryer and
+      // Trealla, and predicate contexts use the predicate-F/A convention.
+      name: 'call_with_error_context/2 requires a pair as its context element',
+      run: () => {
+        const bad = ':- use_module(library(error)).\n%% goal: answer(X)\n' +
+          'answer(C) :- catch(call_with_error_context(true, x), error(E,_), C = E).\n';
+        const result = runCli(['-'], { input: bad });
+        assertEqual(result.status, 0, `exit status; stderr=${result.stderr}`);
+        assertIncludes(result.stdout, 'answer(type_error(pair, x))', 'non-pair element rejected');
+
+        const unbound = ':- use_module(library(error)).\n%% goal: answer(X)\n' +
+          'answer(C) :- catch(call_with_error_context(true, _), error(E,_), C = E).\n';
+        const varResult = runCli(['-'], { input: unbound });
+        assertIncludes(varResult.stdout, 'answer(instantiation_error)', 'unbound element rejected');
+
+        const good = ':- use_module(library(error)).\n%% goal: answer(X)\n' +
+          'answer(ok) :- call_with_error_context(true, a-b).\n';
+        const okResult = runCli(['-'], { input: good });
+        assertIncludes(okResult.stdout, 'answer(ok)', 'pair element accepted');
+      },
+    },
     {
       // Nesting prepends outermost-first and keeps the raising predicate last.
       name: 'nested call_with_error_context/2 accumulates outermost first',
@@ -4518,7 +4558,7 @@ answer(Result) :- countdown(2048, Result), Result = 2048.
           'answer(C) :- catch(call_with_error_context(call_with_error_context(atom_length(1.0,_), inner-1), outer-2), error(_,C), true).\n';
         const result = runCli(['-'], { input });
         assertEqual(result.status, 0, `exit status; stderr=${result.stderr}`);
-        assertIncludes(result.stdout, 'answer([outer - 2, inner - 1, atom_length / 2])', 'nesting order');
+        assertIncludes(result.stdout, 'answer([outer - 2, inner - 1, predicate - atom_length / 2])', 'nesting order');
       },
     },
     {
@@ -4527,7 +4567,7 @@ answer(Result) :- countdown(2048, Result), Result = 2048.
       name: 'call_with_error_context/2 copies the context element',
       run: () => {
         const input = ':- use_module(library(error)).\n%% goal: answer(X)\n' +
-          'answer(ok) :- catch(call_with_error_context(atom_length(1.0,_), ctx(V)), error(_,[ctx(W)|_]), (V == W -> fail ; true)).\n';
+          'answer(ok) :- catch(call_with_error_context(atom_length(1.0,_), ctx-V), error(_,[ctx-W|_]), (V == W -> fail ; true)).\n';
         const result = runCli(['-'], { input });
         assertEqual(result.status, 0, `exit status; stderr=${result.stderr}`);
         assertIncludes(result.stdout, 'answer(ok)', 'context element is a fresh copy');
@@ -5152,7 +5192,7 @@ answer(Result) :- countdown(2048, Result), Result = 2048.
             goal: 'answer(T)',
             ioOptions: { input: invalidOctal },
           }).stdout,
-          'answer(error(syntax_error(read_term), [read / 1])).\n',
+          'answer(error(syntax_error(read_term), [predicate - read / 1])).\n',
           'read/1 rejects non-octal numeric escape',
         );
       },

package/test/run-iso-strict.mjs

@@ -649,7 +649,7 @@ export function runIsoStrict(reporter = new TestReporter()) {
           'close(tmp_in)',
           'current_input(C)',
           'stream_property(C,alias(user_input))',
-          'catch(set_input(tmp_in),error(existence_error(stream,tmp_in),[set_input/1]),true)',
+          'catch(set_input(tmp_in),error(existence_error(stream,tmp_in),[predicate-set_input/1]),true)',
         ].join(','),
       }).stats.completed_goal_lists, 1, 'stream-term, alias lifetime, target/current input, and close fallback');
 
@@ -856,14 +856,14 @@ export function runIsoStrict(reporter = new TestReporter()) {
 
   reporter.test('closes the ISO 7.12 processor error envelope and classification rows', () => {
     const caught = [
-      "catch(atom_length(X,N),error(instantiation_error,[atom_length/2]),true)",
-      "catch(atom_length(1,N),error(type_error(atom,1),[atom_length/2]),true)",
-      "catch(op(1300,xfx,foo),error(domain_error(operator_priority,1300),[op/3]),true)",
+      "catch(atom_length(X,N),error(instantiation_error,[predicate-atom_length/2]),true)",
+      "catch(atom_length(1,N),error(type_error(atom,1),[predicate-atom_length/2]),true)",
+      "catch(op(1300,xfx,foo),error(domain_error(operator_priority,1300),[predicate-op/3]),true)",
       "catch(call(no_such_predicate),error(existence_error(procedure,no_such_predicate/0),[]),true)",
-      "catch(abolish(atom/1),error(permission_error(modify,static_procedure,atom/1),[abolish/1]),true)",
-      "catch(char_code(C,1114112),error(representation_error(character_code),[char_code/2]),true)",
-      "catch(X is 1/0,error(evaluation_error(zero_divisor),[(is)/2]),true)",
-      "catch(X is 1<<4294967296,error(resource_error(memory),[(is)/2]),true)",
+      "catch(abolish(atom/1),error(permission_error(modify,static_procedure,atom/1),[predicate-abolish/1]),true)",
+      "catch(char_code(C,1114112),error(representation_error(character_code),[predicate-char_code/2]),true)",
+      "catch(X is 1/0,error(evaluation_error(zero_divisor),[predicate-(is)/2]),true)",
+      "catch(X is 1<<4294967296,error(resource_error(memory),[predicate-(is)/2]),true)",
     ];
     for (const goal of caught) {
       equal(run('', { isoStrict: true, goal }).stats.completed_goal_lists, 1, goal);
@@ -871,14 +871,14 @@ export function runIsoStrict(reporter = new TestReporter()) {
 
     equal(run('', {
       isoStrict: true,
-      goal: "catch(read_term(T,[]),error(syntax_error(read_term),[read_term/2]),true)",
+      goal: "catch(read_term(T,[]),error(syntax_error(read_term),[predicate-read_term/2]),true)",
       ioOptions: { input: "'unterminated." },
     }).stats.completed_goal_lists, 1, 'syntax error uses error/2 envelope and implementation-defined context');
 
     const systemSolver = new Solver(Program.parse('', { isoStrict: true }), { isoStrict: true });
     systemSolver.io.flush = () => { throw new Error('simulated host I/O failure'); };
     equal([...systemSolver.solve([
-      parseGoalText('catch(flush_output(user_output),error(system_error,[flush_output/1]),true)', { isoStrict: true }),
+      parseGoalText('catch(flush_output(user_output),error(system_error,[predicate-flush_output/1]),true)', { isoStrict: true }),
     ], new Env(), 0)].length, 1, 'system error uses error/2 envelope and implementation-defined context');
 
     // ISO 7.12 deliberately leaves the choice implementation-dependent when