tla-ts 0.0.10-dev.09e53c2a6 → 0.0.10-dev.1ebc153bd
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/compile.cjs +3 -3
- package/dist/compile.js +1 -1
- package/dist/deciders.cjs +36 -36
- package/dist/deciders.js +54 -54
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +2 -1
- package/dist/index.d.ts +2 -1
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove-worker.cjs +1 -1
- package/dist/prove-worker.js +1 -1
- package/dist/prove.cjs +43 -43
- package/dist/prove.js +78 -78
- package/dist/run.cjs +33 -35
- package/dist/run.js +44 -46
- package/dist/tlapm.cjs +1 -1
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +43 -43
- package/dist/transfer.js +38 -38
- package/dist/worker.cjs +6 -6
- package/dist/worker.js +6 -6
- package/package.json +1 -1
- package/src/ast.ts +1 -0
- package/src/bags.ts +46 -28
- package/src/check-trace.ts +2 -16
- package/src/check.ts +152 -64
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/tlc-arguments.ts +2 -2
- package/src/cli/tlc-output.ts +1 -2
- package/src/cli/tlc.ts +13 -8
- package/src/cli/xml-exporter.ts +1 -1
- package/src/codegen.ts +9 -5
- package/src/dependencies.ts +49 -9
- package/src/dfid.ts +9 -2
- package/src/environment.ts +57 -33
- package/src/errors.ts +7 -0
- package/src/evaluate.ts +92 -32
- package/src/exit-codes.ts +4 -2
- package/src/instances.ts +5 -5
- package/src/java-overrides.ts +2 -2
- package/src/levels.ts +138 -90
- package/src/liveness-checker.ts +43 -4
- package/src/liveness.ts +1 -1
- package/src/obligations/index.ts +1 -1
- package/src/obligations/normalize.ts +1 -4
- package/src/obligations/printer.ts +5 -5
- package/src/parallel-worker.ts +8 -2
- package/src/parallel.ts +5 -0
- package/src/parser.ts +106 -144
- package/src/prover/isabelle/isar/attrib.ts +4 -4
- package/src/prover/isabelle/isar/rule-cases.ts +8 -6
- package/src/prover/isabelle/provers/clasimp.ts +1 -1
- package/src/prover/isabelle/provers/hypsubst.ts +2 -2
- package/src/prover/isabelle/pure/rewriter.ts +3 -3
- package/src/prover/isabelle/pure/term.ts +3 -3
- package/src/prover/prep/md5.ts +26 -29
- package/src/prover/smt/rewrite.ts +2 -7
- package/src/prover/smt/simplify.ts +1 -1
- package/src/prover/smt/solver/asserted-formulas.ts +66 -1
- package/src/prover/smt/solver/ast-lt.ts +1 -1
- package/src/prover/smt/solver/ast.ts +58 -11
- package/src/prover/smt/solver/blast-term-ite.ts +47 -0
- package/src/prover/smt/solver/bound-simplifier.ts +2 -3
- package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
- package/src/prover/smt/solver/bv-rewriter.ts +1 -1
- package/src/prover/smt/solver/card2bv.ts +3 -5
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +2 -3
- package/src/prover/smt/solver/context.ts +24 -3
- package/src/prover/smt/solver/ctx-simplify.ts +1 -2
- package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
- package/src/prover/smt/solver/dependent-expr-state.ts +9 -4
- package/src/prover/smt/solver/diff-neq.ts +1 -2
- package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +4 -7
- package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/egraph.ts +4 -10
- package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
- package/src/prover/smt/solver/euf/mam.ts +1 -5
- package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
- package/src/prover/smt/solver/euf/th-solver.ts +0 -7
- package/src/prover/smt/solver/expr2polynomial.ts +204 -79
- package/src/prover/smt/solver/factor.ts +36 -14
- package/src/prover/smt/solver/fd-solver.ts +2 -0
- package/src/prover/smt/solver/fix-dl-var.ts +1 -2
- package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
- package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
- package/src/prover/smt/solver/goal.ts +6 -3
- package/src/prover/smt/solver/goal2nlsat.ts +57 -30
- package/src/prover/smt/solver/hashtable.ts +4 -0
- package/src/prover/smt/solver/logic-tactics.ts +9 -2
- package/src/prover/smt/solver/lp/containers.ts +7 -1
- package/src/prover/smt/solver/lp/cross-nested.ts +1 -3
- package/src/prover/smt/solver/lp/lp-settings.ts +1 -1
- package/src/prover/smt/solver/lp/nex-creator.ts +3 -2
- package/src/prover/smt/solver/lp/nex.ts +2 -1
- package/src/prover/smt/solver/lp/nla-core.ts +1 -1
- package/src/prover/smt/solver/lp/nla-grobner.ts +158 -80
- package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
- package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
- package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
- package/src/prover/smt/solver/lp/pdd.ts +725 -290
- package/src/prover/smt/solver/lp/union-find.ts +1 -1
- package/src/prover/smt/solver/mam-compiler.ts +1 -1
- package/src/prover/smt/solver/model-based-opt.ts +1 -1
- package/src/prover/smt/solver/model-generator.ts +3 -1
- package/src/prover/smt/solver/mpf.ts +2 -4
- package/src/prover/smt/solver/mus.ts +2 -3
- package/src/prover/smt/solver/muz/dl-context.ts +10 -4
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
- package/src/prover/smt/solver/muz/dl-rule.ts +2 -2
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
- package/src/prover/smt/solver/muz/horn-tactic.ts +1 -1
- package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
- package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
- package/src/prover/smt/solver/nlqsat.ts +1 -1
- package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
- package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
- package/src/prover/smt/solver/nlsat/explain.ts +375 -217
- package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
- package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
- package/src/prover/smt/solver/nlsat/solver.ts +74 -64
- package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
- package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
- package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
- package/src/prover/smt/solver/nnf.ts +6 -2
- package/src/prover/smt/solver/opt-context.ts +9 -3
- package/src/prover/smt/solver/opt-nlsat.ts +29 -18
- package/src/prover/smt/solver/opt-preprocess.ts +1 -1
- package/src/prover/smt/solver/opt-solver.ts +6 -3
- package/src/prover/smt/solver/optsmt.ts +1 -1
- package/src/prover/smt/solver/pb-rewriter.ts +1 -4
- package/src/prover/smt/solver/poly-rewriter.ts +74 -18
- package/src/prover/smt/solver/probes.ts +88 -23
- package/src/prover/smt/solver/proto-model.ts +4 -6
- package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
- package/src/prover/smt/solver/qe-lite.ts +2 -2
- package/src/prover/smt/solver/qe.ts +3 -2
- package/src/prover/smt/solver/quantifier-manager.ts +14 -9
- package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
- package/src/prover/smt/solver/rlimit.ts +4 -0
- package/src/prover/smt/solver/sat/config.ts +1 -1
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +26 -1
- package/src/prover/smt/solver/sat/model-converter.ts +1 -1
- package/src/prover/smt/solver/sat/pb-solver.ts +1 -1
- package/src/prover/smt/solver/sat/sat-tactic.ts +4 -3
- package/src/prover/smt/solver/sat/simplifier.ts +1 -1
- package/src/prover/smt/solver/sat/solver.ts +25 -47
- package/src/prover/smt/solver/seq-axioms.ts +20 -35
- package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
- package/src/prover/smt/solver/seq-derive.ts +4 -7
- package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
- package/src/prover/smt/solver/seq-monadic.ts +7 -5
- package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
- package/src/prover/smt/solver/seq-re-util.ts +1 -1
- package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
- package/src/prover/smt/solver/seq-regex-live.ts +2 -2
- package/src/prover/smt/solver/seq-rewriter.ts +31 -29
- package/src/prover/smt/solver/seq-skolem.ts +0 -23
- package/src/prover/smt/solver/seq-view-witness.ts +4 -4
- package/src/prover/smt/solver/smt-kernel.ts +9 -3
- package/src/prover/smt/solver/smt-setup.ts +68 -6
- package/src/prover/smt/solver/smtlib-parser.ts +558 -220
- package/src/prover/smt/solver/smtlib-script.ts +495 -153
- package/src/prover/smt/solver/solve-eqs.ts +13 -21
- package/src/prover/smt/solver/tactic.ts +219 -130
- package/src/prover/smt/solver/theory-bv.ts +2 -2
- package/src/prover/smt/solver/theory-lra-final-check.ts +1 -1
- package/src/prover/smt/solver/theory-lra-internalize.ts +1 -0
- package/src/prover/smt/solver/theory-lra-propagate.ts +6 -4
- package/src/prover/smt/solver/theory-lra.ts +0 -1
- package/src/prover/smt/solver/theory-pb.ts +24 -7
- package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
- package/src/prover/smt/solver/theory-seq-state.ts +2 -21
- package/src/prover/tlapm/cache.ts +8 -8
- package/src/prover/zenon/equality-rules.ts +24 -0
- package/src/prover/zenon/expr.ts +21 -0
- package/src/prover/zenon/index-table.ts +7 -2
- package/src/prover/zenon/isar-case.ts +1 -1
- package/src/prover/zenon/isar.ts +2 -2
- package/src/prover/zenon/phrase.ts +1 -1
- package/src/prover/zenon/rules.ts +2 -1
- package/src/resolve.ts +624 -187
- package/src/runtime.ts +3 -1
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +2 -13
- package/src/sany/generator-definitions.ts +3 -1
- package/src/sany/generator-expressions.ts +36 -30
- package/src/sany/generator-proofs.ts +5 -3
- package/src/sany/generator.ts +2 -1
- package/src/sany/lexer.ts +3 -3
- package/src/sany/modules.ts +4 -2
- package/src/sany/nodes.ts +1 -1
- package/src/sany/selectors.ts +11 -6
- package/src/sany/xml.ts +2 -3
- package/src/search.ts +51 -22
- package/src/spec-description.ts +2 -2
- package/src/subexpressions.ts +265 -94
- package/src/successors.ts +1 -0
- package/src/symmetry.ts +1 -1
- package/src/tlc/jar-data.ts +10 -0
- package/src/tlc/messages.ts +3 -3
- package/src/tlc/order.ts +14 -3
- package/src/tlc/tlc-operators.ts +3 -1
- package/src/tlc/tlcext-operators.ts +18 -5
- package/src/tlc/trace-spec.ts +5 -5
- package/src/typed-tier.ts +29 -23
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +46 -27
package/src/subexpressions.ts
CHANGED
|
@@ -16,15 +16,21 @@ import {
|
|
|
16
16
|
} from "./ast";
|
|
17
17
|
import { formatRange, TlaSyntaxError } from "./errors";
|
|
18
18
|
import { getSourceName, mapChildren, mapDefinition } from "./instances";
|
|
19
|
+
import { resolveSynonym } from "./tlc/jar-data";
|
|
19
20
|
import {
|
|
20
21
|
getArity,
|
|
21
22
|
getBinder,
|
|
22
23
|
getNameSelectors,
|
|
23
24
|
getOperandIndex,
|
|
24
25
|
getOperands,
|
|
26
|
+
getParamArities,
|
|
27
|
+
isBefore,
|
|
25
28
|
LOCAL_RESOLUTION,
|
|
29
|
+
nullSelections,
|
|
26
30
|
selectionErrors,
|
|
27
31
|
selections,
|
|
32
|
+
type NullSelection,
|
|
33
|
+
type SelectionArguments,
|
|
28
34
|
} from "./resolve";
|
|
29
35
|
|
|
30
36
|
type Lookup = (name: string) => Definition | undefined;
|
|
@@ -49,6 +55,29 @@ interface SelectingName {
|
|
|
49
55
|
|
|
50
56
|
const SELECTION_NAME = "$subexpression";
|
|
51
57
|
|
|
58
|
+
const getSelectorName = (selector: Selector) => {
|
|
59
|
+
switch (selector.kind) {
|
|
60
|
+
case "Name":
|
|
61
|
+
return selector.name;
|
|
62
|
+
case "Operand":
|
|
63
|
+
return typeof selector.operand === "number"
|
|
64
|
+
? `argument selector ${selector.operand}`
|
|
65
|
+
: selector.operand;
|
|
66
|
+
case "Bound":
|
|
67
|
+
return "!(...)";
|
|
68
|
+
case "At":
|
|
69
|
+
return "@";
|
|
70
|
+
case "Colon":
|
|
71
|
+
return ":";
|
|
72
|
+
}
|
|
73
|
+
};
|
|
74
|
+
|
|
75
|
+
const getExpressionArguments = (
|
|
76
|
+
operator: string,
|
|
77
|
+
range: SourceRange | undefined,
|
|
78
|
+
args: Expression[],
|
|
79
|
+
): SelectionArguments => ({ operator, range, args, params: args.map(() => 0) });
|
|
80
|
+
|
|
52
81
|
const createError = (message: string, location: SourceLocation) =>
|
|
53
82
|
new TlaSyntaxError(`${message} at line ${location.line}, column ${location.column}`);
|
|
54
83
|
|
|
@@ -152,21 +181,26 @@ const applyDefinition = (definition: Definition, selection: Selection) => {
|
|
|
152
181
|
const selectSubexpression = (
|
|
153
182
|
selectors: Selector[],
|
|
154
183
|
lookup: Lookup,
|
|
184
|
+
isGoal: (name: string) => boolean,
|
|
155
185
|
reference: Expression & SelectingName,
|
|
156
186
|
isOperator: boolean,
|
|
157
187
|
): Expression => {
|
|
158
188
|
const location = reference.location;
|
|
159
189
|
const selection: Selection = { params: [], args: [], lets: [], location };
|
|
160
190
|
let selectorIndex = 0;
|
|
161
|
-
let current
|
|
191
|
+
let current: Expression | undefined;
|
|
162
192
|
let isFailed = false;
|
|
193
|
+
const nulls: NullSelection[] = [];
|
|
194
|
+
const applications: SelectionArguments[] = [];
|
|
195
|
+
const checkNull = (node: Expression | undefined, message: string) => {
|
|
196
|
+
const range = reference.selectorRanges?.[selectorIndex];
|
|
197
|
+
if (node && range) nulls.push({ node, error: { location: formatRange(range), message } });
|
|
198
|
+
};
|
|
163
199
|
|
|
164
200
|
const report = (range: SourceRange | undefined, message: string) => {
|
|
165
201
|
if (!range) throw createError(message, location);
|
|
166
202
|
selectionErrors.set(reference, {
|
|
167
|
-
|
|
168
|
-
.slice(0, selectorIndex)
|
|
169
|
-
.flatMap((selector) => ("args" in selector ? selector.args : [])),
|
|
203
|
+
applications,
|
|
170
204
|
error: { location: formatRange(range), message },
|
|
171
205
|
});
|
|
172
206
|
isFailed = true;
|
|
@@ -178,6 +212,7 @@ const selectSubexpression = (
|
|
|
178
212
|
const args: Expression[] = [];
|
|
179
213
|
while (selectorIndex < selectors.length) {
|
|
180
214
|
const selector = selectors[selectorIndex];
|
|
215
|
+
if (selector.kind !== "Name" && !local) return undefined;
|
|
181
216
|
if (selector.kind !== "Name") throw createError("Expected an operator name", location);
|
|
182
217
|
names.push(selector.name);
|
|
183
218
|
args.push(...selector.args);
|
|
@@ -194,16 +229,38 @@ const selectSubexpression = (
|
|
|
194
229
|
|
|
195
230
|
const enterDefinition = (local: Definition[] | undefined) => {
|
|
196
231
|
const found = findDefinition(local);
|
|
232
|
+
if (!found) {
|
|
233
|
+
isFailed = true;
|
|
234
|
+
return undefined;
|
|
235
|
+
}
|
|
197
236
|
const definition = found.definition;
|
|
198
237
|
const arity = getArity(definition);
|
|
199
238
|
const isLast = selectorIndex === selectors.length - 1;
|
|
200
239
|
if (found.args.length !== arity && (!isOperator || found.args.length !== 0)) {
|
|
201
240
|
return report(
|
|
202
241
|
reference.argumentRanges?.[selectorIndex] ?? location.range,
|
|
203
|
-
`The operator ${found.name} requires ${arity - found.earlier} arguments.`,
|
|
242
|
+
`The operator ${resolveSynonym(found.name)} requires ${arity - found.earlier} arguments.`,
|
|
204
243
|
);
|
|
205
244
|
}
|
|
206
245
|
if (isLast) return { definition, args: found.args };
|
|
246
|
+
applications.push({
|
|
247
|
+
operator: found.name,
|
|
248
|
+
range: reference.selectorRanges?.[selectorIndex],
|
|
249
|
+
args: found.args,
|
|
250
|
+
params: getParamArities(definition),
|
|
251
|
+
});
|
|
252
|
+
const range = definition.location.range;
|
|
253
|
+
if (
|
|
254
|
+
definition.isRecursive &&
|
|
255
|
+
range &&
|
|
256
|
+
range.module === location.range?.module &&
|
|
257
|
+
isBefore(location, range.end)
|
|
258
|
+
) {
|
|
259
|
+
return report(
|
|
260
|
+
reference.selectorRanges?.[selectorIndex],
|
|
261
|
+
`Subexpression of \`${found.name}' used inside the operator's definition.`,
|
|
262
|
+
);
|
|
263
|
+
}
|
|
207
264
|
if (definition.kind !== "Operator") {
|
|
208
265
|
throw createError(`Cannot select a subexpression of ${definition.name}`, location);
|
|
209
266
|
}
|
|
@@ -228,6 +285,7 @@ const selectSubexpression = (
|
|
|
228
285
|
selection.lets.push(...found.lets);
|
|
229
286
|
selection.params.push(...params.map((name) => ({ name, arity: 0 })));
|
|
230
287
|
selection.args.push(...selector.args);
|
|
288
|
+
applications.push(getExpressionArguments(selector.name, range, selector.args));
|
|
231
289
|
current = found.label.body;
|
|
232
290
|
selectorIndex++;
|
|
233
291
|
}
|
|
@@ -236,14 +294,42 @@ const selectSubexpression = (
|
|
|
236
294
|
const selectOperand = (selector: Selector) => {
|
|
237
295
|
if (!current) throw createError("Subexpression selection failed", location);
|
|
238
296
|
if (selector.kind === "Colon") return;
|
|
297
|
+
const range = reference.selectorRanges?.[selectorIndex];
|
|
298
|
+
const currentRange = current.location.range;
|
|
299
|
+
if (
|
|
300
|
+
(current.kind === "Subexpression" ||
|
|
301
|
+
(current.kind === "Identifier" && current.name.includes("!")) ||
|
|
302
|
+
(current.kind === "Apply" && current.operator.includes("!"))) &&
|
|
303
|
+
(currentRange?.module !== location.range?.module || isBefore(current.location, location))
|
|
304
|
+
) {
|
|
305
|
+
const selected = resolveSubexpressions(current, lookup, isGoal);
|
|
306
|
+
if (selectionErrors.has(selected)) {
|
|
307
|
+
report(
|
|
308
|
+
range,
|
|
309
|
+
`Choosing operand \`${getSelectorName(selector)}' of subexpression with no operands.`,
|
|
310
|
+
);
|
|
311
|
+
return;
|
|
312
|
+
}
|
|
313
|
+
if (selections.has(selected) && selected.kind !== "Lambda") {
|
|
314
|
+
current =
|
|
315
|
+
selected.kind === "Let" &&
|
|
316
|
+
selected.body.kind === "Apply" &&
|
|
317
|
+
selected.body.operator === SELECTION_NAME
|
|
318
|
+
? selected.body
|
|
319
|
+
: // SANY wraps a selection without parameters in $Nop, whose only operand is the selection.
|
|
320
|
+
{ kind: "Tuple", elements: [selected], location: selected.location };
|
|
321
|
+
}
|
|
322
|
+
}
|
|
239
323
|
if (current.kind === "Label") {
|
|
240
324
|
current = current.body;
|
|
241
325
|
selectOperand(selector);
|
|
242
326
|
return;
|
|
243
327
|
}
|
|
328
|
+
const nonexistent = `Nonexistent operand specified by \`${getSelectorName(selector)}'.`;
|
|
244
329
|
if (current.kind === "Let") {
|
|
245
330
|
if (selector.kind !== "Operand" || getOperandIndex(selector.operand, 1) !== 0) {
|
|
246
|
-
|
|
331
|
+
report(range, "A LET/IN expression has only one operand.");
|
|
332
|
+
return;
|
|
247
333
|
}
|
|
248
334
|
selection.lets.push(current.definitions);
|
|
249
335
|
current = current.body;
|
|
@@ -252,32 +338,63 @@ const selectSubexpression = (
|
|
|
252
338
|
const binder = getBinder(current);
|
|
253
339
|
if (binder && (selector.kind === "Bound" || selector.kind === "At")) {
|
|
254
340
|
selection.params.push(...binder.names.map((name) => ({ name, arity: 0 })));
|
|
255
|
-
if (selector.kind === "Bound")
|
|
341
|
+
if (selector.kind === "Bound") {
|
|
342
|
+
selection.args.push(...selector.args);
|
|
343
|
+
applications.push(getExpressionArguments("", range, selector.args));
|
|
344
|
+
}
|
|
256
345
|
current = binder.body;
|
|
257
346
|
return;
|
|
258
347
|
}
|
|
259
|
-
if (current.kind === "Case"
|
|
348
|
+
if (current.kind === "Case") {
|
|
260
349
|
const arms = [
|
|
261
350
|
...current.arms,
|
|
262
351
|
...(current.other ? [{ condition: undefined, body: current.other }] : []),
|
|
263
352
|
];
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
353
|
+
if (selectorIndex === selectors.length - 1) {
|
|
354
|
+
report(range, "Subexpression of CASE must have form !i!j.");
|
|
355
|
+
return;
|
|
356
|
+
}
|
|
357
|
+
const arm =
|
|
358
|
+
selector.kind === "Operand"
|
|
359
|
+
? arms[getOperandIndex(selector.operand, arms.length)]
|
|
360
|
+
: undefined;
|
|
361
|
+
if (!arm) {
|
|
362
|
+
report(range, nonexistent);
|
|
363
|
+
return;
|
|
268
364
|
}
|
|
269
365
|
selectorIndex++;
|
|
270
|
-
const
|
|
271
|
-
const
|
|
272
|
-
|
|
366
|
+
const next = selectors[selectorIndex];
|
|
367
|
+
const part = next.kind === "Operand" ? getOperandIndex(next.operand, 2) : -1;
|
|
368
|
+
const nextRange = reference.selectorRanges?.[selectorIndex];
|
|
369
|
+
if (part === -1) {
|
|
370
|
+
report(
|
|
371
|
+
nextRange,
|
|
372
|
+
"Second selector for CASE subexpression must specify one of two operands.",
|
|
373
|
+
);
|
|
374
|
+
return;
|
|
375
|
+
}
|
|
376
|
+
const chosen = part === 0 ? arm.condition : arm.body;
|
|
377
|
+
if (!chosen) {
|
|
378
|
+
report(nextRange, "Selecting OTHER in a CASE statement.");
|
|
379
|
+
return;
|
|
380
|
+
}
|
|
273
381
|
current = chosen;
|
|
274
382
|
return;
|
|
275
383
|
}
|
|
276
|
-
if (selector.kind !== "Operand")
|
|
277
|
-
throw createError("Unexpected subexpression selector", location);
|
|
278
384
|
const operands = binder ? binder.sets : getOperands(current);
|
|
385
|
+
if (!operands && current.kind !== "Identifier") {
|
|
386
|
+
report(range, "Selecting subexpression of expression that has none.");
|
|
387
|
+
return;
|
|
388
|
+
}
|
|
389
|
+
if (selector.kind !== "Operand") {
|
|
390
|
+
report(range, nonexistent);
|
|
391
|
+
return;
|
|
392
|
+
}
|
|
279
393
|
const operand = operands?.[getOperandIndex(selector.operand, operands.length)];
|
|
280
|
-
if (!operand)
|
|
394
|
+
if (!operand) {
|
|
395
|
+
report(range, nonexistent);
|
|
396
|
+
return;
|
|
397
|
+
}
|
|
281
398
|
current = operand;
|
|
282
399
|
};
|
|
283
400
|
|
|
@@ -304,12 +421,30 @@ const selectSubexpression = (
|
|
|
304
421
|
followLabels();
|
|
305
422
|
continue;
|
|
306
423
|
}
|
|
424
|
+
if (selector.kind !== "Colon") {
|
|
425
|
+
checkNull(
|
|
426
|
+
current,
|
|
427
|
+
"Subexpression selection failed, probably due to an error in the selected expression.",
|
|
428
|
+
);
|
|
429
|
+
}
|
|
307
430
|
selectOperand(selector);
|
|
431
|
+
checkNull(
|
|
432
|
+
current,
|
|
433
|
+
`An unexpected null node specified by '${getSelectorName(selectors[selectorIndex])}'.\nThis is probably due to a previous error.`,
|
|
434
|
+
);
|
|
308
435
|
selectorIndex++;
|
|
309
436
|
}
|
|
310
437
|
if (isFailed) return reference;
|
|
311
438
|
if (!current) throw createError("Subexpression selection failed", location);
|
|
312
|
-
|
|
439
|
+
const params = selection.params.length;
|
|
440
|
+
const args = selection.args.length;
|
|
441
|
+
if (params !== args && (!isOperator || args > 0)) {
|
|
442
|
+
report(location.range, `Expected ${params} arguments but found ${args}.`);
|
|
443
|
+
return reference;
|
|
444
|
+
}
|
|
445
|
+
const selected = createApplication(selection, current);
|
|
446
|
+
nullSelections.set(selected, nulls);
|
|
447
|
+
return selected;
|
|
313
448
|
};
|
|
314
449
|
|
|
315
450
|
const getQualifiedSelectors = (
|
|
@@ -373,7 +508,8 @@ const resolveSubexpressions = (
|
|
|
373
508
|
: undefined;
|
|
374
509
|
const first = selectors?.[0];
|
|
375
510
|
if (!selectors || (first?.kind === "Name" && isGoal(first.name))) return mapped;
|
|
376
|
-
|
|
511
|
+
if (first?.kind === "Name" && selectors[1].kind !== "Name" && !lookup(first.name)) return mapped;
|
|
512
|
+
const selected = selectSubexpression(selectors, lookup, isGoal, mapped, isOperator);
|
|
377
513
|
if (selected !== mapped) selections.add(selected);
|
|
378
514
|
return selected;
|
|
379
515
|
};
|
|
@@ -427,89 +563,122 @@ export const resolveModuleSubexpressions = (module: Module, available: Definitio
|
|
|
427
563
|
},
|
|
428
564
|
];
|
|
429
565
|
});
|
|
430
|
-
const
|
|
566
|
+
const own = new Set([...module.definitions, ...clauses]);
|
|
567
|
+
const recursive = new Map(
|
|
568
|
+
module.units.flatMap((unit): [string, SourceLocation][] =>
|
|
569
|
+
unit.kind === "Recursive"
|
|
570
|
+
? unit.declarations.map((declaration) => [declaration.name, declaration.location])
|
|
571
|
+
: [],
|
|
572
|
+
),
|
|
573
|
+
);
|
|
574
|
+
const isDeclaredBefore = (definition: Definition, location: SourceLocation) => {
|
|
575
|
+
const declared = recursive.get(definition.name);
|
|
576
|
+
return (
|
|
577
|
+
isBefore(definition.location, location) ||
|
|
578
|
+
(definition.isRecursive && declared !== undefined && isBefore(declared, location))
|
|
579
|
+
);
|
|
580
|
+
};
|
|
581
|
+
const getVisibleLookup =
|
|
582
|
+
(lookup: Lookup, location: SourceLocation): Lookup =>
|
|
583
|
+
(name) => {
|
|
584
|
+
const definition = lookup(name);
|
|
585
|
+
return definition && (!own.has(definition) || isDeclaredBefore(definition, location))
|
|
586
|
+
? definition
|
|
587
|
+
: undefined;
|
|
588
|
+
};
|
|
589
|
+
const proofLookup = createLookup([...available, ...module.definitions]);
|
|
431
590
|
const isGoal = (name: string) => goals.has(name);
|
|
432
591
|
const definitionLookup = createLookup([...available, ...module.definitions, ...clauses]);
|
|
433
|
-
const resolve = (expression: Expression) =>
|
|
592
|
+
const resolve = (expression: Expression, location: SourceLocation) =>
|
|
434
593
|
resolveSubexpressions(
|
|
435
594
|
expression,
|
|
436
|
-
definitionLookup,
|
|
595
|
+
getVisibleLookup(definitionLookup, location),
|
|
437
596
|
(name) => isGoal(name) && clauses.every((clause) => clause.name !== name),
|
|
438
597
|
);
|
|
439
|
-
const
|
|
440
|
-
|
|
441
|
-
|
|
442
|
-
|
|
443
|
-
|
|
444
|
-
|
|
445
|
-
|
|
446
|
-
|
|
447
|
-
|
|
448
|
-
|
|
449
|
-
|
|
450
|
-
assumptions: statement.assumptions.map((assumption) =>
|
|
451
|
-
assumption.kind === "NewSymbol"
|
|
452
|
-
? { ...assumption, set: assumption.set && resolveInProof(assumption.set) }
|
|
453
|
-
: resolveStatement(assumption),
|
|
454
|
-
),
|
|
455
|
-
conclusion: resolveInProof(statement.conclusion),
|
|
456
|
-
}
|
|
457
|
-
: resolveInProof(statement);
|
|
458
|
-
const resolveStep = (body: StepBody): StepBody => {
|
|
459
|
-
switch (body.kind) {
|
|
460
|
-
case "Use":
|
|
461
|
-
case "Hide":
|
|
462
|
-
return { ...body, facts: resolveFacts(body.facts) };
|
|
463
|
-
case "Instance":
|
|
464
|
-
return resolveInstance(body, lookup, isProofGoal);
|
|
465
|
-
case "Define":
|
|
466
|
-
return {
|
|
467
|
-
...body,
|
|
468
|
-
definitions: body.definitions.map((definition) =>
|
|
469
|
-
definition.kind === "Instance"
|
|
470
|
-
? resolveInstance(definition, lookup, isProofGoal)
|
|
471
|
-
: mapDefinition(definition, resolveInProof),
|
|
472
|
-
),
|
|
473
|
-
};
|
|
474
|
-
case "Have":
|
|
475
|
-
case "Case":
|
|
476
|
-
return { ...body, expression: resolveInProof(body.expression) };
|
|
477
|
-
case "Witness":
|
|
478
|
-
return { ...body, expressions: body.expressions.map(resolveInProof) };
|
|
479
|
-
case "Take":
|
|
480
|
-
return { ...body, bounds: resolveBounds(body.bounds) };
|
|
481
|
-
case "Pick":
|
|
482
|
-
return { ...body, bounds: resolveBounds(body.bounds), body: resolveInProof(body.body) };
|
|
483
|
-
case "Assert":
|
|
484
|
-
return { ...body, statement: resolveStatement(body.statement) };
|
|
485
|
-
default:
|
|
486
|
-
return body;
|
|
487
|
-
}
|
|
488
|
-
};
|
|
489
|
-
const resolveProof = (proof: Proof | undefined): Proof | undefined =>
|
|
490
|
-
proof?.kind === "By"
|
|
491
|
-
? { ...proof, facts: resolveFacts(proof.facts) }
|
|
492
|
-
: proof?.kind === "Steps"
|
|
598
|
+
const createProofResolver = (location: SourceLocation) => {
|
|
599
|
+
const lookup = getVisibleLookup(proofLookup, location);
|
|
600
|
+
const isProofGoal = (name: string) => isGoal(name) || !lookup(name);
|
|
601
|
+
const resolveInProof = (expression: Expression) =>
|
|
602
|
+
resolveSubexpressions(expression, lookup, isProofGoal);
|
|
603
|
+
const resolveFacts = (facts: Fact[]) =>
|
|
604
|
+
facts.map((fact) => (fact.kind === "ModuleFact" ? fact : resolveInProof(fact)));
|
|
605
|
+
const resolveBounds = (bounds: Bound[]) =>
|
|
606
|
+
bounds.map((bound) => ({ ...bound, set: resolveInProof(bound.set) }));
|
|
607
|
+
const resolveStatement = (statement: Expression | AssumeProve): Expression | AssumeProve =>
|
|
608
|
+
statement.kind === "AssumeProve"
|
|
493
609
|
? {
|
|
494
|
-
...
|
|
495
|
-
|
|
496
|
-
|
|
497
|
-
|
|
498
|
-
|
|
499
|
-
|
|
610
|
+
...statement,
|
|
611
|
+
assumptions: statement.assumptions.map((assumption) =>
|
|
612
|
+
assumption.kind === "NewSymbol"
|
|
613
|
+
? { ...assumption, set: assumption.set && resolveInProof(assumption.set) }
|
|
614
|
+
: resolveStatement(assumption),
|
|
615
|
+
),
|
|
616
|
+
conclusion: resolveInProof(statement.conclusion),
|
|
500
617
|
}
|
|
501
|
-
:
|
|
618
|
+
: resolveInProof(statement);
|
|
619
|
+
const resolveStep = (body: StepBody): StepBody => {
|
|
620
|
+
switch (body.kind) {
|
|
621
|
+
case "Use":
|
|
622
|
+
case "Hide":
|
|
623
|
+
return { ...body, facts: resolveFacts(body.facts) };
|
|
624
|
+
case "Instance":
|
|
625
|
+
return resolveInstance(body, lookup, isProofGoal);
|
|
626
|
+
case "Define":
|
|
627
|
+
return {
|
|
628
|
+
...body,
|
|
629
|
+
definitions: body.definitions.map((definition) =>
|
|
630
|
+
definition.kind === "Instance"
|
|
631
|
+
? resolveInstance(definition, lookup, isProofGoal)
|
|
632
|
+
: mapDefinition(definition, resolveInProof),
|
|
633
|
+
),
|
|
634
|
+
};
|
|
635
|
+
case "Have":
|
|
636
|
+
case "Case":
|
|
637
|
+
return { ...body, expression: resolveInProof(body.expression) };
|
|
638
|
+
case "Witness":
|
|
639
|
+
return { ...body, expressions: body.expressions.map(resolveInProof) };
|
|
640
|
+
case "Take":
|
|
641
|
+
return { ...body, bounds: resolveBounds(body.bounds) };
|
|
642
|
+
case "Pick":
|
|
643
|
+
return { ...body, bounds: resolveBounds(body.bounds), body: resolveInProof(body.body) };
|
|
644
|
+
case "Assert":
|
|
645
|
+
return { ...body, statement: resolveStatement(body.statement) };
|
|
646
|
+
default:
|
|
647
|
+
return body;
|
|
648
|
+
}
|
|
649
|
+
};
|
|
650
|
+
const resolveProof = (proof: Proof | undefined): Proof | undefined =>
|
|
651
|
+
proof?.kind === "By"
|
|
652
|
+
? { ...proof, facts: resolveFacts(proof.facts) }
|
|
653
|
+
: proof?.kind === "Steps"
|
|
654
|
+
? {
|
|
655
|
+
...proof,
|
|
656
|
+
steps: proof.steps.map((step) => ({
|
|
657
|
+
...step,
|
|
658
|
+
body: resolveStep(step.body),
|
|
659
|
+
proof: resolveProof(step.proof),
|
|
660
|
+
})),
|
|
661
|
+
}
|
|
662
|
+
: proof;
|
|
663
|
+
return { resolveFacts, resolveStatement, resolveProof };
|
|
664
|
+
};
|
|
502
665
|
const resolved = {
|
|
503
666
|
...module,
|
|
504
|
-
theorems: module.theorems.map((theorem) =>
|
|
505
|
-
|
|
506
|
-
|
|
507
|
-
theorem
|
|
508
|
-
|
|
509
|
-
|
|
510
|
-
|
|
667
|
+
theorems: module.theorems.map((theorem) => {
|
|
668
|
+
const resolver = createProofResolver(theorem.location);
|
|
669
|
+
return {
|
|
670
|
+
...theorem,
|
|
671
|
+
statement:
|
|
672
|
+
theorem.name !== undefined && theorem.statement.kind !== "AssumeProve"
|
|
673
|
+
? theorem.statement
|
|
674
|
+
: resolver.resolveStatement(theorem.statement),
|
|
675
|
+
proof: resolver.resolveProof(theorem.proof),
|
|
676
|
+
};
|
|
677
|
+
}),
|
|
678
|
+
uses: module.uses.map((use) => ({
|
|
679
|
+
...use,
|
|
680
|
+
facts: createProofResolver(use.location).resolveFacts(use.facts),
|
|
511
681
|
})),
|
|
512
|
-
uses: module.uses.map((use) => ({ ...use, facts: resolveFacts(use.facts) })),
|
|
513
682
|
};
|
|
514
683
|
const hasReferences =
|
|
515
684
|
module.definitions.some((definition) => containsReference(definition.body)) ||
|
|
@@ -517,10 +686,12 @@ export const resolveModuleSubexpressions = (module: Module, available: Definitio
|
|
|
517
686
|
if (!hasReferences) return resolved;
|
|
518
687
|
return {
|
|
519
688
|
...resolved,
|
|
520
|
-
definitions: module.definitions.map((definition) =>
|
|
689
|
+
definitions: module.definitions.map((definition) =>
|
|
690
|
+
mapDefinition(definition, (expression) => resolve(expression, definition.location)),
|
|
691
|
+
),
|
|
521
692
|
assumptions: module.assumptions.map((assumption) => ({
|
|
522
693
|
...assumption,
|
|
523
|
-
expression: resolve(assumption.expression),
|
|
694
|
+
expression: resolve(assumption.expression, assumption.location),
|
|
524
695
|
})),
|
|
525
696
|
};
|
|
526
697
|
};
|
package/src/successors.ts
CHANGED
|
@@ -723,6 +723,7 @@ const compileIdentifier = (
|
|
|
723
723
|
!definition ||
|
|
724
724
|
(expression.location.range && getStartupValue(definition, environment) !== undefined)
|
|
725
725
|
) {
|
|
726
|
+
// Deviation from TLC: Tool#getInitStates prints an unassigned variable's declaration as the non-boolean value it found.
|
|
726
727
|
guard(run, scope, partial, action, isFixed, onComplete);
|
|
727
728
|
return;
|
|
728
729
|
}
|
package/src/symmetry.ts
CHANGED
package/src/tlc/jar-data.ts
CHANGED
|
@@ -143,6 +143,16 @@ export const SANY_OPERATOR_SYNONYMS = [
|
|
|
143
143
|
["^+", "⁺"],
|
|
144
144
|
];
|
|
145
145
|
|
|
146
|
+
const SYNONYMS = new Map(
|
|
147
|
+
SANY_OPERATOR_SYNONYMS.flatMap((names) => names.slice(1).map((synonym) => [synonym, names[0]])),
|
|
148
|
+
);
|
|
149
|
+
|
|
150
|
+
export const resolveSynonym = (name: string) =>
|
|
151
|
+
name
|
|
152
|
+
.split("!")
|
|
153
|
+
.map((part) => SYNONYMS.get(part) ?? (part === "~" ? "\\lnot" : part))
|
|
154
|
+
.join("!");
|
|
155
|
+
|
|
146
156
|
export const TLC_STARTUP_STRINGS = [
|
|
147
157
|
"STRING",
|
|
148
158
|
"FALSE",
|
package/src/tlc/messages.ts
CHANGED
|
@@ -345,14 +345,14 @@ interface CodedMessage {
|
|
|
345
345
|
let codedMessagePatterns: { pattern: RegExp; message: CodedMessage }[] | undefined;
|
|
346
346
|
|
|
347
347
|
const getCodedMessagePatterns = () =>
|
|
348
|
-
(codedMessagePatterns ??= CODED_MESSAGES.map((
|
|
348
|
+
(codedMessagePatterns ??= CODED_MESSAGES.map((codedMessage) => ({
|
|
349
349
|
pattern: new RegExp(
|
|
350
|
-
`^${
|
|
350
|
+
`^${codedMessage[1]
|
|
351
351
|
.split(/%\d+%/)
|
|
352
352
|
.map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
|
|
353
353
|
.join("[\\s\\S]*")}$`,
|
|
354
354
|
),
|
|
355
|
-
message: { code, isEvalException },
|
|
355
|
+
message: { code: codedMessage[0], isEvalException: codedMessage[2] },
|
|
356
356
|
})));
|
|
357
357
|
|
|
358
358
|
const UNCODED_MESSAGE_PATTERN =
|
package/src/tlc/order.ts
CHANGED
|
@@ -444,7 +444,11 @@ const createContexts = (getParsed: ModuleSet) => {
|
|
|
444
444
|
};
|
|
445
445
|
};
|
|
446
446
|
|
|
447
|
-
const getStringOrder = (
|
|
447
|
+
const getStringOrder = (
|
|
448
|
+
getParsed: ModuleSet,
|
|
449
|
+
config: ModelConfig,
|
|
450
|
+
runtimeModules: string[],
|
|
451
|
+
): string[] => {
|
|
448
452
|
const order = new Set<string>();
|
|
449
453
|
const intern = (text: string) => {
|
|
450
454
|
order.add(text);
|
|
@@ -541,12 +545,19 @@ const getStringOrder = (getParsed: ModuleSet, config: ModelConfig): string[] =>
|
|
|
541
545
|
});
|
|
542
546
|
};
|
|
543
547
|
analyze(undefined);
|
|
548
|
+
runtimeModules.forEach((name) => {
|
|
549
|
+
const tokens = getUnitTokens(name);
|
|
550
|
+
getParsedTexts(tokens).forEach(intern);
|
|
551
|
+
tokens.forEach((token) => {
|
|
552
|
+
if (token.kind === "String") intern(token.text);
|
|
553
|
+
});
|
|
554
|
+
});
|
|
544
555
|
TLC_RUNTIME_STRINGS.forEach(intern);
|
|
545
556
|
return [...order];
|
|
546
557
|
};
|
|
547
558
|
|
|
548
559
|
export interface TlcOrder {
|
|
549
|
-
getStringOrder: (config: ModelConfig) => string[];
|
|
560
|
+
getStringOrder: (config: ModelConfig, runtimeModules: string[]) => string[];
|
|
550
561
|
getDeclarationOrder: (kind: "variable" | "constant") => string[];
|
|
551
562
|
createDefinitionOrder: () => (name: string | undefined) => string[];
|
|
552
563
|
parseModule: (source: string) => Module;
|
|
@@ -558,7 +569,7 @@ export const createTlcOrder = (source: string, loadModule: ModuleLoader): TlcOrd
|
|
|
558
569
|
let contexts: ReturnType<typeof createContexts> | undefined;
|
|
559
570
|
const getContexts = () => (contexts ??= createContexts(getParsed));
|
|
560
571
|
return {
|
|
561
|
-
getStringOrder: (config) => getStringOrder(getParsed, config),
|
|
572
|
+
getStringOrder: (config, runtimeModules) => getStringOrder(getParsed, config, runtimeModules),
|
|
562
573
|
getDeclarationOrder: (kind) =>
|
|
563
574
|
getContexts()
|
|
564
575
|
.getContext(undefined)
|
package/src/tlc/tlc-operators.ts
CHANGED
|
@@ -43,7 +43,9 @@ const formatCalendarVersion = (date: Date) =>
|
|
|
43
43
|
`${date.getUTCFullYear()}.${zeroPad(date.getUTCMonth() + 1)}.${zeroPad(date.getUTCDate())}.${zeroPad(date.getUTCHours())}${zeroPad(date.getUTCMinutes())}${zeroPad(date.getUTCSeconds())}`;
|
|
44
44
|
|
|
45
45
|
const getRegisterFunction = <Key extends Value>(registers: Map<Key, Value>) =>
|
|
46
|
-
createFunction(
|
|
46
|
+
createFunction(
|
|
47
|
+
[...registers].map((entry): [Value, Value] => [entry[0], createTuple([entry[1]])]),
|
|
48
|
+
);
|
|
47
49
|
|
|
48
50
|
const createTlcRecord = (fields: [string, Value][]) =>
|
|
49
51
|
setFunctionClass(createWrittenFunction(fields), "record");
|
|
@@ -263,10 +263,13 @@ export const createTlcExtOperators = (
|
|
|
263
263
|
defineOperator("TLCNoOp", 1, (args) => getValue(args, 0, "TLCNoOp")),
|
|
264
264
|
{
|
|
265
265
|
...defineLazyOperator("PickSuccessor", 1, (args, context) => {
|
|
266
|
-
// Deviation from TLC: TLCExt#pickSuccessor fingerprints a partial successor and fails, where TLCExt.tla promises TRUE.
|
|
267
266
|
const next = context?.next ?? (context?.environment.variables ?? []).map(() => undefined);
|
|
268
|
-
|
|
269
|
-
if (
|
|
267
|
+
// A simulation remembers no states, so TLC evaluates the guard before it looks at the successor.
|
|
268
|
+
if (runtime.getSimulationValue === undefined) {
|
|
269
|
+
// Deviation from TLC: TLCExt#pickSuccessor fingerprints a partial successor and fails, where TLCExt.tla promises TRUE.
|
|
270
|
+
if (!isCompleteState(next)) return true;
|
|
271
|
+
if (context?.next && runtime.isSeen(next)) return true;
|
|
272
|
+
}
|
|
270
273
|
const guard = getOperator(args, 0, "PickSuccessor");
|
|
271
274
|
const isPicked = guard.call([]);
|
|
272
275
|
if (typeof isPicked !== "boolean") {
|
|
@@ -274,7 +277,13 @@ export const createTlcExtOperators = (
|
|
|
274
277
|
`In evaluating TLCExt!PickSuccessor, a non-boolean expression (${getKindString(isPicked)}) was used as the condition of an IF.\n${guard.expression ? describeNode(guard.expression) : ""}`,
|
|
275
278
|
);
|
|
276
279
|
}
|
|
277
|
-
if (
|
|
280
|
+
if (
|
|
281
|
+
isPicked ||
|
|
282
|
+
!context?.next ||
|
|
283
|
+
!isCompleteState(next) ||
|
|
284
|
+
!context.state ||
|
|
285
|
+
!isCompleteState(context.state)
|
|
286
|
+
) {
|
|
278
287
|
return true;
|
|
279
288
|
}
|
|
280
289
|
const state = context.state;
|
|
@@ -303,9 +312,13 @@ export const createTlcExtOperators = (
|
|
|
303
312
|
} else if (answer[0] === "d") {
|
|
304
313
|
printOverride(formatState(runtime.toRecord(next), runtime.toRecord(state)));
|
|
305
314
|
} else if (answer[0] === "e") {
|
|
315
|
+
if (runtime.markExplored) {
|
|
316
|
+
runtime.markExplored(next);
|
|
317
|
+
return true;
|
|
318
|
+
}
|
|
306
319
|
if (runtime.getSimulationValue === undefined) {
|
|
307
320
|
throw new TlaUnsupportedError(
|
|
308
|
-
"tla-ts can't mark a state explored while it
|
|
321
|
+
"tla-ts can't mark a state explored while it searches depth first.",
|
|
309
322
|
);
|
|
310
323
|
}
|
|
311
324
|
printOverride(
|