tla-ts 0.0.10-dev.c92e6a4ea → 0.0.10-dev.d166e0ae9
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 +13 -3
- package/dist/index.d.ts +13 -3
- 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 +68 -68
- package/dist/prove.js +78 -78
- package/dist/run.cjs +42 -42
- package/dist/run.js +44 -44
- package/dist/tlapm.cjs +1 -1
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +45 -43
- package/dist/transfer.js +45 -43
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +11 -1
- package/src/bags.ts +50 -29
- package/src/builtins.ts +4 -3
- package/src/check-failure.ts +9 -6
- package/src/check-trace.ts +116 -64
- package/src/check.ts +356 -173
- package/src/cli/tlc-output.ts +1 -0
- package/src/cli/tlc.ts +4 -3
- package/src/cli/xml-exporter.ts +1 -1
- package/src/codegen.ts +34 -13
- package/src/coverage.ts +3 -0
- package/src/dependencies.ts +61 -13
- package/src/dfid.ts +22 -10
- package/src/environment.ts +71 -35
- package/src/errors.ts +7 -0
- package/src/evaluate.ts +149 -54
- package/src/exit-codes.ts +29 -15
- package/src/instances.ts +16 -6
- package/src/java-hash.ts +14 -0
- package/src/java-overrides.ts +2 -2
- package/src/levels.ts +186 -97
- package/src/liveness-checker.ts +131 -83
- package/src/liveness.ts +52 -11
- package/src/obligations/index.ts +1 -1
- package/src/obligations/normalize.ts +1 -4
- package/src/obligations/printer.ts +5 -5
- package/src/obligations/source.ts +2 -0
- package/src/parser.ts +115 -145
- 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/arith-rewriter.ts +11 -3
- package/src/prover/smt/solver/array-rewriter.ts +12 -2
- package/src/prover/smt/solver/asserted-formulas.ts +169 -58
- package/src/prover/smt/solver/ast-lt.ts +1 -1
- package/src/prover/smt/solver/ast.ts +63 -14
- package/src/prover/smt/solver/auf-solver.ts +23 -12
- package/src/prover/smt/solver/bit-blast-tactic.ts +26 -0
- package/src/prover/smt/solver/blast-term-ite.ts +47 -0
- package/src/prover/smt/solver/bound-simplifier.ts +11 -13
- 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 +35 -18
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
- package/src/prover/smt/solver/context.ts +67 -13
- 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 +26 -15
- package/src/prover/smt/solver/diff-neq.ts +1 -2
- package/src/prover/smt/solver/dt2bv-tactic.ts +36 -20
- package/src/prover/smt/solver/elim-bounds.ts +89 -0
- package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
- 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 -11
- 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 +148 -39
- 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/internalizer.ts +1 -1
- package/src/prover/smt/solver/logic-tactics.ts +9 -2
- package/src/prover/smt/solver/lp/lp-settings.ts +5 -1
- package/src/prover/smt/solver/lp/nla-core.ts +1 -1
- package/src/prover/smt/solver/lp/nla-grobner.ts +2 -2
- package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
- package/src/prover/smt/solver/lp/pdd.ts +2 -3
- 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/maxcore.ts +2 -1
- package/src/prover/smt/solver/maxsmt-base.ts +1 -0
- package/src/prover/smt/solver/model-based-opt.ts +1 -1
- package/src/prover/smt/solver/model-checker.ts +1 -1
- package/src/prover/smt/solver/model-evaluator.ts +2 -0
- package/src/prover/smt/solver/model-generator.ts +85 -43
- 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 +22 -44
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
- package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
- package/src/prover/smt/solver/muz/hnf.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 +15 -2
- package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
- 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/muz/spacer-prop-solver.ts +1 -1
- 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 +21 -7
- package/src/prover/smt/solver/opt-nlsat.ts +29 -18
- package/src/prover/smt/solver/opt-pareto.ts +19 -0
- package/src/prover/smt/solver/opt-preprocess.ts +1 -1
- package/src/prover/smt/solver/opt-solver.ts +10 -6
- package/src/prover/smt/solver/optsmt.ts +1 -1
- package/src/prover/smt/solver/parallel-tactic.ts +1 -1
- package/src/prover/smt/solver/pb-rewriter.ts +1 -4
- package/src/prover/smt/solver/poly-rewriter.ts +75 -18
- package/src/prover/smt/solver/probes.ts +88 -23
- package/src/prover/smt/solver/proto-model.ts +8 -8
- package/src/prover/smt/solver/push-app-ite.ts +37 -0
- 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/qsat.ts +23 -8
- 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/rewriter-tpl.ts +7 -6
- package/src/prover/smt/solver/rewriter.ts +31 -25
- 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/goal2sat.ts +0 -1
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +81 -28
- 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 +17 -7
- package/src/prover/smt/solver/sat/sat2goal.ts +10 -7
- 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 +2 -2
- 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-consequences.ts +1 -1
- package/src/prover/smt/solver/smt-kernel.ts +48 -7
- package/src/prover/smt/solver/smt-setup.ts +96 -10
- package/src/prover/smt/solver/smtlib-parser.ts +589 -224
- package/src/prover/smt/solver/smtlib-script.ts +674 -195
- package/src/prover/smt/solver/solve-eqs.ts +36 -37
- package/src/prover/smt/solver/solver.ts +18 -3
- package/src/prover/smt/solver/tactic.ts +332 -189
- package/src/prover/smt/solver/theory-bv.ts +13 -3
- package/src/prover/smt/solver/theory-fpa.ts +1 -1
- package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
- package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
- package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
- package/src/prover/smt/solver/theory-lra.ts +1 -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/smt/solver/tseitin-cnf.ts +1 -0
- package/src/prover/tlapm/cache.ts +8 -8
- package/src/prover/zenon/index-table.ts +5 -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/resolve.ts +1071 -251
- package/src/runtime.ts +5 -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 +38 -30
- package/src/sany/generator-proofs.ts +6 -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 +197 -117
- package/src/simulate.ts +165 -102
- package/src/spec-description.ts +8 -6
- package/src/standard-modules.ts +56 -22
- package/src/subexpressions.ts +518 -123
- package/src/successors.ts +10 -3
- package/src/symmetry.ts +2 -1
- package/src/tlc/jar-data.ts +10 -0
- package/src/tlc/messages.ts +3 -3
- package/src/tlc/random.ts +2 -1
- package/src/tlc/replay.ts +27 -14
- package/src/tlc/tlc-operators.ts +10 -8
- package/src/tlc/tlcext-operators.ts +26 -10
- package/src/tlc/trace-spec.ts +9 -22
- package/src/typed-tier.ts +44 -27
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +135 -78
package/src/cli/tlc-output.ts
CHANGED
|
@@ -548,6 +548,7 @@ export const printResult = (result: CheckResult, printer: MessagePrinter, timing
|
|
|
548
548
|
printTrace(printer, failure.trace, "error-trace");
|
|
549
549
|
const traceFailure = failure.traceFailure;
|
|
550
550
|
if (traceFailure) {
|
|
551
|
+
printTraceOutput(printer, traceFailure.output);
|
|
551
552
|
print(
|
|
552
553
|
traceFailure.code,
|
|
553
554
|
MESSAGE_LEVEL.error,
|
package/src/cli/tlc.ts
CHANGED
|
@@ -280,8 +280,9 @@ const checkSpec = async (
|
|
|
280
280
|
} else {
|
|
281
281
|
printError(error, printer);
|
|
282
282
|
}
|
|
283
|
-
|
|
284
|
-
|
|
283
|
+
const exitCode = getTopLevelExitCode(error);
|
|
284
|
+
if (exitCode !== EXIT_STATUS.abort) printFinished();
|
|
285
|
+
return exitCode;
|
|
285
286
|
};
|
|
286
287
|
const config = (() => {
|
|
287
288
|
try {
|
|
@@ -591,7 +592,7 @@ export const checkSpecs = async (args: string[], java: JavaProperties) => {
|
|
|
591
592
|
exitCodes.push(
|
|
592
593
|
await reportErrors(async () => {
|
|
593
594
|
const specPath = path.endsWith(".ts") ? await writeTypeScriptSpec(path) : path;
|
|
594
|
-
//
|
|
595
|
+
// An extension: TLC refuses more than one spec, and tla-ts checks each one under its name.
|
|
595
596
|
if (paths.length > 1) {
|
|
596
597
|
console.log(`Checking ${basename(specPath)} with ${basename(specPath, ".tla")}.cfg`);
|
|
597
598
|
}
|
package/src/cli/xml-exporter.ts
CHANGED
|
@@ -52,7 +52,7 @@ const XML_EXPORT_USAGE = (() => {
|
|
|
52
52
|
"",
|
|
53
53
|
getBold("OPTIONS"),
|
|
54
54
|
"",
|
|
55
|
-
...options.map((
|
|
55
|
+
...options.map((option) => `\t${getBold(option[0])}\n\t\t${option[1]}`),
|
|
56
56
|
"",
|
|
57
57
|
getBold("TIPS"),
|
|
58
58
|
"",
|
package/src/codegen.ts
CHANGED
|
@@ -14,6 +14,7 @@ import {
|
|
|
14
14
|
getFunctionBuilder,
|
|
15
15
|
getLazyFilter,
|
|
16
16
|
isKeptLazy,
|
|
17
|
+
isUniformPredicate,
|
|
17
18
|
getDomainOperator,
|
|
18
19
|
getSubsetOperator,
|
|
19
20
|
getEvaluator,
|
|
@@ -161,23 +162,37 @@ const createLocal = (generator: Generator) => `local${generator.counter++}`;
|
|
|
161
162
|
const getFreeNames = (expression: Expression, names = new Set<string>()) => {
|
|
162
163
|
const name = getReferencedName(expression);
|
|
163
164
|
if (name !== undefined) names.add(name);
|
|
164
|
-
|
|
165
|
+
if (expression.kind !== "Selection") {
|
|
166
|
+
getChildren(expression).forEach((child) => getFreeNames(child, names));
|
|
167
|
+
}
|
|
165
168
|
return names;
|
|
166
169
|
};
|
|
167
170
|
|
|
168
|
-
const getDelegateContext = (
|
|
171
|
+
const getDelegateContext = (
|
|
172
|
+
generator: Generator,
|
|
173
|
+
expression: Expression,
|
|
174
|
+
frame: Frame,
|
|
175
|
+
isEveryLocalCaptured = false,
|
|
176
|
+
) => {
|
|
169
177
|
const freeNames = getFreeNames(expression);
|
|
170
|
-
const captured = [...frame.locals].filter(
|
|
178
|
+
const captured = [...frame.locals].filter(
|
|
179
|
+
(entry) => isEveryLocalCaptured || freeNames.has(entry[0]),
|
|
180
|
+
);
|
|
171
181
|
if (captured.length === 0) return frame.context;
|
|
172
182
|
const names = addReference(
|
|
173
183
|
generator,
|
|
174
|
-
captured.map((
|
|
184
|
+
captured.map((entry) => entry[0]),
|
|
175
185
|
);
|
|
176
|
-
return `extend(${frame.context}, ${names}, [${captured.map((
|
|
186
|
+
return `extend(${frame.context}, ${names}, [${captured.map((entry) => entry[1]).join(", ")}])`;
|
|
177
187
|
};
|
|
178
188
|
|
|
179
|
-
const generateDelegate = (
|
|
180
|
-
|
|
189
|
+
const generateDelegate = (
|
|
190
|
+
generator: Generator,
|
|
191
|
+
expression: Expression,
|
|
192
|
+
frame: Frame,
|
|
193
|
+
isEveryLocalCaptured = false,
|
|
194
|
+
) =>
|
|
195
|
+
`${addReference(generator, getEvaluator(expression, generator.environment))}(${getDelegateContext(generator, expression, frame, isEveryLocalCaptured)})`;
|
|
181
196
|
|
|
182
197
|
const generateHelper = (
|
|
183
198
|
generator: Generator,
|
|
@@ -267,7 +282,8 @@ const generateSetFilter = (
|
|
|
267
282
|
const lazy = `if (!isReducible(${base})) return ${filterLazily}(${base}, ${getDelegateContext(generator, expression, bodyFrame)});`;
|
|
268
283
|
const set = generateExpression(generator, expression.bound.set, bodyFrame);
|
|
269
284
|
bodyFrame.locals.set(name, element);
|
|
270
|
-
const
|
|
285
|
+
const stop = isUniformPredicate(expression, generator.environment) ? " else break;" : "";
|
|
286
|
+
const test = `if (filterPredicate(${generateExpression(generator, expression.predicate, bodyFrame)}, ${node})) addBounded(${kept}, ${element});${stop}`;
|
|
271
287
|
return `const ${base} = ${set}; ${lazy} const ${list} = ${base}.kind === "Interval" ? ${base} : finiteElements(${base}); const ${kept} = []; ${generateLoop(generator, list, element, test)} return normalizedSet(${kept});`;
|
|
272
288
|
});
|
|
273
289
|
|
|
@@ -318,9 +334,10 @@ const generateApply = (
|
|
|
318
334
|
const domain = addReference(generator, getDomainOperator(expression));
|
|
319
335
|
return `${domain}(${generateExpression(generator, args[0], frame)})`;
|
|
320
336
|
}
|
|
321
|
-
|
|
322
|
-
if (builtin.name === "
|
|
323
|
-
|
|
337
|
+
// TLC caches a constant TLCEval only where no name is bound, so the delegate sees every local.
|
|
338
|
+
if (builtin.name === "TLCEval") return generateDelegate(generator, expression, frame, true);
|
|
339
|
+
if (builtin.name === "\\subseteq" && builtin.evaluateBinary && args.length === 2) {
|
|
340
|
+
const subset = addReference(generator, getSubsetOperator(expression, builtin.evaluateBinary));
|
|
324
341
|
return `${subset}(${generateExpression(generator, args[0], frame)}, ${generateExpression(generator, args[1], frame)})`;
|
|
325
342
|
}
|
|
326
343
|
const environment = generator.environment;
|
|
@@ -440,12 +457,16 @@ const generateExpression = (generator: Generator, expression: Expression, frame:
|
|
|
440
457
|
generator,
|
|
441
458
|
fields.map((field) => field.name),
|
|
442
459
|
);
|
|
443
|
-
const values = `[${fields.map((field) => generate(field.value)).join(", ")}]`;
|
|
460
|
+
const values = `[${expression.fields.map((field) => generate(field.value)).join(", ")}]`;
|
|
444
461
|
const writtenNames = expression.fields.map((field) => field.name);
|
|
445
462
|
if (writtenNames.every((name, index) => name === fields[index].name)) {
|
|
446
463
|
return `record(${names}, ${values})`;
|
|
447
464
|
}
|
|
448
|
-
|
|
465
|
+
const writtenIndexes = addReference(
|
|
466
|
+
generator,
|
|
467
|
+
fields.map((field) => expression.fields.indexOf(field)),
|
|
468
|
+
);
|
|
469
|
+
return `writtenRecord(${names}, ${writtenIndexes}, ${values}, ${addReference(generator, writtenNames)})`;
|
|
449
470
|
}
|
|
450
471
|
case "Tuple":
|
|
451
472
|
return `tuple([${expression.elements.map((element) => generate(element)).join(", ")}])`;
|
package/src/coverage.ts
CHANGED
|
@@ -380,6 +380,9 @@ export const buildCoverage = (
|
|
|
380
380
|
case "Lambda":
|
|
381
381
|
walk(expression.body, bindNames(expression.params, locals));
|
|
382
382
|
return;
|
|
383
|
+
case "Selection":
|
|
384
|
+
walk(expression.expression, locals);
|
|
385
|
+
return;
|
|
383
386
|
case "Let": {
|
|
384
387
|
const inner = expression.definitions.reduce<Local | undefined>(
|
|
385
388
|
(parent, definition) => ({ name: definition.name, definition, scope: undefined, parent }),
|
package/src/dependencies.ts
CHANGED
|
@@ -29,6 +29,7 @@ const VARIABLE_LEVEL_FLAGS = 32;
|
|
|
29
29
|
const ACTION_LEVEL_FLAGS = VARIABLE_LEVEL_FLAGS | 64;
|
|
30
30
|
const TEMPORAL_LEVEL_FLAGS = ACTION_LEVEL_FLAGS | 128;
|
|
31
31
|
const RANDOM = 256;
|
|
32
|
+
const ABOVE_CONSTANT_BOUND = 512;
|
|
32
33
|
|
|
33
34
|
const ACTION_KINDS = new Set<Expression["kind"]>([
|
|
34
35
|
"Prime",
|
|
@@ -80,6 +81,7 @@ interface Edge {
|
|
|
80
81
|
callee: Definition;
|
|
81
82
|
isOverridden: boolean;
|
|
82
83
|
isLevelCounted: boolean;
|
|
84
|
+
isOperatorArgument: boolean;
|
|
83
85
|
}
|
|
84
86
|
|
|
85
87
|
const collectLocalFacts = (
|
|
@@ -104,20 +106,34 @@ const collectLocalFacts = (
|
|
|
104
106
|
}
|
|
105
107
|
return undefined;
|
|
106
108
|
};
|
|
107
|
-
const
|
|
109
|
+
const contexts = new Map<Expression, number>();
|
|
110
|
+
const visit = (node: Expression, isLevelCounted: boolean, isOperatorArgument: boolean) => {
|
|
108
111
|
const kind = node.kind;
|
|
112
|
+
if (kind === "Selection") {
|
|
113
|
+
const seen = contexts.get(node.expression) ?? 0;
|
|
114
|
+
const context = isLevelCounted ? (isOperatorArgument ? 1 : 2) : isOperatorArgument ? 4 : 8;
|
|
115
|
+
if ((seen & context) !== 0) return;
|
|
116
|
+
contexts.set(node.expression, seen | context);
|
|
117
|
+
}
|
|
118
|
+
// TLC's getLevelBound takes an operator argument for a constant.
|
|
119
|
+
const nonconstantFlags = isOperatorArgument ? NONCONSTANT : NONCONSTANT | ABOVE_CONSTANT_BOUND;
|
|
109
120
|
if (
|
|
110
121
|
NONCONSTANT_KINDS.has(kind) ||
|
|
111
122
|
(kind === "UnboundedQuantifier" && node.isTemporal === true) ||
|
|
112
123
|
(kind === "Apply" && NONCONSTANT_OPERATORS.has(node.operator))
|
|
113
124
|
) {
|
|
114
|
-
row[0] |=
|
|
125
|
+
row[0] |= nonconstantFlags;
|
|
115
126
|
}
|
|
116
127
|
if (NONCONSTANT_KINDS.has(kind)) row[0] |= READS_IMPURE;
|
|
117
128
|
const ownLevelFlags = getOwnLevelFlags(node);
|
|
118
129
|
if (isLevelCounted && ownLevelFlags !== undefined) row[0] |= ownLevelFlags;
|
|
119
130
|
const isInnerLevelCounted = isLevelCounted && ownLevelFlags === undefined;
|
|
120
131
|
const name = getReferencedName(node);
|
|
132
|
+
// TLC's getLevelBound takes a parameter named like a variable for that variable.
|
|
133
|
+
if (name !== undefined && isLocallyResolved(node) && environment.variableIndex.has(name)) {
|
|
134
|
+
if (!isOperatorArgument) row[0] |= ABOVE_CONSTANT_BOUND;
|
|
135
|
+
if (isInnerLevelCounted) row[0] |= VARIABLE_LEVEL_FLAGS;
|
|
136
|
+
}
|
|
121
137
|
if (name !== undefined && !isLocallyResolved(node)) {
|
|
122
138
|
const target = environment.substitutions.get(name) ?? name;
|
|
123
139
|
const definition = environment.definitions.get(target);
|
|
@@ -128,20 +144,30 @@ const collectLocalFacts = (
|
|
|
128
144
|
environment.builtins.get(name)?.isStateLevel ||
|
|
129
145
|
(definition && environment.variableIndex.has(definition.name))
|
|
130
146
|
) {
|
|
131
|
-
row[0] |=
|
|
147
|
+
row[0] |= nonconstantFlags;
|
|
132
148
|
}
|
|
133
149
|
if (variableIndex !== undefined) {
|
|
134
150
|
if (isInnerLevelCounted) row[0] |= VARIABLE_LEVEL_FLAGS;
|
|
135
151
|
if (!isOverridden) row[1 + (variableIndex >>> 5)] |= 1 << (variableIndex & 31);
|
|
136
152
|
}
|
|
137
153
|
if (definition) {
|
|
138
|
-
edges.push({
|
|
154
|
+
edges.push({
|
|
155
|
+
callee: definition,
|
|
156
|
+
isOverridden,
|
|
157
|
+
isLevelCounted: isInnerLevelCounted,
|
|
158
|
+
isOperatorArgument:
|
|
159
|
+
isOperatorArgument ||
|
|
160
|
+
kind === "OperatorReference" ||
|
|
161
|
+
(kind === "Identifier" &&
|
|
162
|
+
definition.kind === "Operator" &&
|
|
163
|
+
definition.params.length > 0),
|
|
164
|
+
});
|
|
139
165
|
} else {
|
|
140
|
-
if (isImpureBuiltin(
|
|
141
|
-
row[0] |= IMPURE | (
|
|
166
|
+
if (isImpureBuiltin(target, environment)) {
|
|
167
|
+
row[0] |= IMPURE | (target === "Assert" ? 0 : REPEATED_EFFECT);
|
|
142
168
|
}
|
|
143
|
-
if (STREAMED_BUILTINS.has(
|
|
144
|
-
if (RANDOM_BUILTINS.has(
|
|
169
|
+
if (STREAMED_BUILTINS.has(target)) row[0] |= STREAMED;
|
|
170
|
+
if (RANDOM_BUILTINS.has(target)) row[0] |= RANDOM;
|
|
145
171
|
if (!isOverridden && isImpureBuiltin(target, environment)) row[0] |= READS_IMPURE;
|
|
146
172
|
const builtin = environment.builtins.get(target);
|
|
147
173
|
if (
|
|
@@ -155,9 +181,11 @@ const collectLocalFacts = (
|
|
|
155
181
|
}
|
|
156
182
|
}
|
|
157
183
|
}
|
|
158
|
-
getChildren(node).forEach((child) =>
|
|
184
|
+
getChildren(node).forEach((child) =>
|
|
185
|
+
visit(child, isInnerLevelCounted, isOperatorArgument || kind === "Lambda"),
|
|
186
|
+
);
|
|
159
187
|
};
|
|
160
|
-
expressions.forEach((expression) => visit(expression, true));
|
|
188
|
+
expressions.forEach((expression) => visit(expression, true, false));
|
|
161
189
|
return { row, edges };
|
|
162
190
|
};
|
|
163
191
|
|
|
@@ -230,9 +258,10 @@ const closeRows = (local: Uint32Array, words: number, edges: Int32Array[], mask:
|
|
|
230
258
|
|
|
231
259
|
const PURITY_MASK = IMPURE | REPEATED_EFFECT | STREAMED | RANDOM;
|
|
232
260
|
const READ_MASK = NONCONSTANT | READS_IMPURE;
|
|
261
|
+
const STARTUP_MASK = NONCONSTANT | ABOVE_CONSTANT_BOUND;
|
|
233
262
|
|
|
234
263
|
const isEvaluatedOnce = (definition: Definition, flags: number) =>
|
|
235
|
-
definition.kind === "Operator" && definition.params.length === 0 && (flags &
|
|
264
|
+
definition.kind === "Operator" && definition.params.length === 0 && (flags & STARTUP_MASK) === 0;
|
|
236
265
|
|
|
237
266
|
export const createDefinitionFacts = (environment: DefinitionNames): DefinitionFacts => {
|
|
238
267
|
const definitions = [...new Set(environment.definitions.values())];
|
|
@@ -256,18 +285,32 @@ export const createDefinitionFacts = (environment: DefinitionNames): DefinitionF
|
|
|
256
285
|
new Int32Array(own.filter((edge) => !edge.isOverridden && edge.isLevelCounted).map(getId)),
|
|
257
286
|
);
|
|
258
287
|
const levels = closeRows(local, words, levelEdges, TEMPORAL_LEVEL_FLAGS);
|
|
288
|
+
const startupEdges = edges.map(
|
|
289
|
+
(own) =>
|
|
290
|
+
new Int32Array(
|
|
291
|
+
own.filter((edge) => !edge.isOverridden && !edge.isOperatorArgument).map(getId),
|
|
292
|
+
),
|
|
293
|
+
);
|
|
294
|
+
const startup = closeRows(local, words, startupEdges, ABOVE_CONSTANT_BOUND);
|
|
259
295
|
const purityEdges = edges.map(
|
|
260
296
|
(own) =>
|
|
261
297
|
new Int32Array(
|
|
262
298
|
own
|
|
263
299
|
.map(getId)
|
|
264
|
-
.filter(
|
|
300
|
+
.filter(
|
|
301
|
+
(callee) =>
|
|
302
|
+
!isEvaluatedOnce(
|
|
303
|
+
definitions[callee],
|
|
304
|
+
reads[callee * words] | startup[callee * words],
|
|
305
|
+
),
|
|
306
|
+
),
|
|
265
307
|
),
|
|
266
308
|
);
|
|
267
309
|
const purity = closeRows(localImpurity, words, purityEdges, PURITY_MASK);
|
|
268
310
|
const rows = reads.map((word, position) =>
|
|
269
311
|
position % words === 0
|
|
270
312
|
? (word & READ_MASK) |
|
|
313
|
+
(startup[position] & ABOVE_CONSTANT_BOUND) |
|
|
271
314
|
(levels[position] & TEMPORAL_LEVEL_FLAGS) |
|
|
272
315
|
(purity[position] & PURITY_MASK)
|
|
273
316
|
: word,
|
|
@@ -291,6 +334,7 @@ const getExpressionsRow = (expressions: Expression[], environment: Environment)
|
|
|
291
334
|
const callee = getRow(edge.callee, environment);
|
|
292
335
|
if (!edge.isOverridden) {
|
|
293
336
|
row[0] |= callee[0] & READ_MASK;
|
|
337
|
+
if (!edge.isOperatorArgument) row[0] |= callee[0] & ABOVE_CONSTANT_BOUND;
|
|
294
338
|
if (edge.isLevelCounted) row[0] |= callee[0] & TEMPORAL_LEVEL_FLAGS;
|
|
295
339
|
for (let word = 1; word < words; word++) row[word] |= callee[word];
|
|
296
340
|
}
|
|
@@ -300,7 +344,10 @@ const getExpressionsRow = (expressions: Expression[], environment: Environment)
|
|
|
300
344
|
};
|
|
301
345
|
|
|
302
346
|
export const isConstantLevel = (definition: Definition, environment: Environment) =>
|
|
303
|
-
(getRow(definition, environment)[0] &
|
|
347
|
+
(getRow(definition, environment)[0] & STARTUP_MASK) === 0;
|
|
348
|
+
|
|
349
|
+
export const isEvaluatedAtStartup = (definition: Definition, environment: Environment) =>
|
|
350
|
+
(getRow(definition, environment)[0] & ABOVE_CONSTANT_BOUND) === 0;
|
|
304
351
|
|
|
305
352
|
const EFFECT_FLAGS = {
|
|
306
353
|
any: IMPURE,
|
|
@@ -308,6 +355,7 @@ const EFFECT_FLAGS = {
|
|
|
308
355
|
streamed: STREAMED,
|
|
309
356
|
// What a second evaluation shows: output again, or other random draws.
|
|
310
357
|
replayed: REPEATED_EFFECT | RANDOM,
|
|
358
|
+
varying: IMPURE | RANDOM,
|
|
311
359
|
};
|
|
312
360
|
|
|
313
361
|
export const isExpressionImpure = (
|
package/src/dfid.ts
CHANGED
|
@@ -15,7 +15,7 @@ import { EXIT_STATUS, getMessageExitStatus, withLivenessExitCode } from "./exit-
|
|
|
15
15
|
import { createLivenessChecker } from "./liveness-checker";
|
|
16
16
|
import { getIncompleteSuccessorMessage, prepareSearch, reportAssumptionViolation } from "./search";
|
|
17
17
|
import type { SpecAction } from "./spec-description";
|
|
18
|
-
import { forEachInitialState, forEachSuccessor } from "./successors";
|
|
18
|
+
import { forEachInitialState, forEachSuccessor, getSuccessors } from "./successors";
|
|
19
19
|
import {
|
|
20
20
|
formatNestedMessage,
|
|
21
21
|
formatTlcDate,
|
|
@@ -28,7 +28,7 @@ import {
|
|
|
28
28
|
import { getTlcFingerprint } from "./tlc/fingerprint";
|
|
29
29
|
import { replaySuccessors } from "./tlc/replay";
|
|
30
30
|
import { getOptimisticProbability, getActualProbability } from "./tlc/summary";
|
|
31
|
-
import { createModelValue, formatState, getSetBound, type Value } from "./values";
|
|
31
|
+
import { createModelValue, formatState, getSetBound, isSameValue, type Value } from "./values";
|
|
32
32
|
|
|
33
33
|
export interface DepthFirstOptions extends CheckOptions {
|
|
34
34
|
maxDepth: number;
|
|
@@ -131,7 +131,7 @@ export const checkDepthFirst = (options: DepthFirstOptions): number => {
|
|
|
131
131
|
withUnexpectedException(() =>
|
|
132
132
|
createLivenessChecker(temporalProperties, search.spec.temporals, environment, {
|
|
133
133
|
getFingerprint: () => 0,
|
|
134
|
-
|
|
134
|
+
forEachActionSuccessors: () => {},
|
|
135
135
|
}),
|
|
136
136
|
),
|
|
137
137
|
)?.branches;
|
|
@@ -165,6 +165,13 @@ export const checkDepthFirst = (options: DepthFirstOptions): number => {
|
|
|
165
165
|
if (assumptionStatus !== undefined) return assumptionStatus;
|
|
166
166
|
|
|
167
167
|
const nextActions = prepared.getDescription().actions;
|
|
168
|
+
// Deviation from TLC: TLCExt#pickSuccessor casts the DFID checker to ModelChecker and fails, so tla-ts asks as model checking does.
|
|
169
|
+
runtime.getSuccessorAction = (state, next) =>
|
|
170
|
+
nextActions.find((action) =>
|
|
171
|
+
getSuccessors(action.expression, state, environment, action.scope).some((successor) =>
|
|
172
|
+
successor.state.every((value, index) => isSameValue(value, next[index])),
|
|
173
|
+
),
|
|
174
|
+
);
|
|
168
175
|
const statuses = new Map<bigint, number>();
|
|
169
176
|
const fingerprintSet = { level: 1, leveled: 0, buckets: INITIAL_BUCKETS };
|
|
170
177
|
const setStatus = (fingerprint: bigint, status: number) => {
|
|
@@ -261,16 +268,21 @@ export const checkDepthFirst = (options: DepthFirstOptions): number => {
|
|
|
261
268
|
config.alias === undefined
|
|
262
269
|
? search.toRecord(state)
|
|
263
270
|
: search.evaluateAlias(config.alias, state, state, isTool);
|
|
264
|
-
const
|
|
265
|
-
? search.getViolatedInvariants(state)
|
|
266
|
-
: [search.findViolatedInvariant(state)].filter((invariant) => invariant !== undefined);
|
|
267
|
-
for (const invariant of violated) {
|
|
271
|
+
const reportInvariant = (name: string) =>
|
|
268
272
|
message(
|
|
269
273
|
MESSAGE_CODE.invariantViolatedInitial,
|
|
270
|
-
`Invariant ${
|
|
274
|
+
`Invariant ${name} is violated by the initial state:\n${formatState(alias())}`,
|
|
271
275
|
);
|
|
272
|
-
|
|
273
|
-
|
|
276
|
+
if (isContinued) {
|
|
277
|
+
search.forEachViolatedInvariant(state, (invariant) => {
|
|
278
|
+
reportInvariant(invariant.name);
|
|
279
|
+
checker.continuedCode = MESSAGE_CODE.invariantViolatedInitial;
|
|
280
|
+
});
|
|
281
|
+
}
|
|
282
|
+
const violated = isContinued ? undefined : search.findViolatedInvariant(state);
|
|
283
|
+
if (violated) {
|
|
284
|
+
reportInvariant(violated.name);
|
|
285
|
+
return MESSAGE_CODE.invariantViolatedInitial;
|
|
274
286
|
}
|
|
275
287
|
const predicate = search.findFailedInitialPredicate(state);
|
|
276
288
|
if (predicate) {
|
package/src/environment.ts
CHANGED
|
@@ -9,6 +9,7 @@ import {
|
|
|
9
9
|
type Instance,
|
|
10
10
|
type Module,
|
|
11
11
|
type OperatorParam,
|
|
12
|
+
type Proof,
|
|
12
13
|
type SourceLocation,
|
|
13
14
|
} from "./ast";
|
|
14
15
|
import type { ModuleOperator } from "./check";
|
|
@@ -105,7 +106,6 @@ interface EnvironmentOptions {
|
|
|
105
106
|
|
|
106
107
|
export interface RuntimeInvariant {
|
|
107
108
|
name: string;
|
|
108
|
-
/** Undefined when the invariant names a definition of the root module. */
|
|
109
109
|
module: string | undefined;
|
|
110
110
|
}
|
|
111
111
|
|
|
@@ -237,6 +237,19 @@ const getSubstitutions = (instances: Instance[]) =>
|
|
|
237
237
|
instance.substitutions.map((substitution) => substitution.expression),
|
|
238
238
|
);
|
|
239
239
|
|
|
240
|
+
const getProofInstances = (proof: Proof | undefined): Instance[] =>
|
|
241
|
+
proof?.kind === "Steps"
|
|
242
|
+
? proof.steps.flatMap((step) => [
|
|
243
|
+
...(step.body.kind === "Instance" ? [step.body] : []),
|
|
244
|
+
...(step.body.kind === "Define"
|
|
245
|
+
? step.body.definitions.flatMap((definition) =>
|
|
246
|
+
definition.kind === "Instance" ? [definition] : [],
|
|
247
|
+
)
|
|
248
|
+
: []),
|
|
249
|
+
...getProofInstances(step.proof),
|
|
250
|
+
])
|
|
251
|
+
: [];
|
|
252
|
+
|
|
240
253
|
const rejectLiterals = (expressions: Expression[]): void =>
|
|
241
254
|
expressions.forEach((expression) => {
|
|
242
255
|
if (expression.kind === "Decimal") throw createRealNumberError(expression);
|
|
@@ -276,9 +289,10 @@ export const createEnvironment = (
|
|
|
276
289
|
const dependencies = new Map<string, Set<string>>();
|
|
277
290
|
const loading: Set<string>[] = [];
|
|
278
291
|
const linking: string[] = [];
|
|
292
|
+
const usedModules = new Set<string>();
|
|
279
293
|
|
|
280
294
|
const useModule = (name: string, used: Iterable<string>) =>
|
|
281
|
-
loading.forEach((closure) => {
|
|
295
|
+
[usedModules, ...loading].forEach((closure) => {
|
|
282
296
|
closure.add(name);
|
|
283
297
|
[...used].forEach((dependency) => closure.add(dependency));
|
|
284
298
|
});
|
|
@@ -506,7 +520,7 @@ export const createEnvironment = (
|
|
|
506
520
|
const instantiation = createInstantiation({
|
|
507
521
|
params,
|
|
508
522
|
substitutions: new Map(
|
|
509
|
-
[...substitutions].map((
|
|
523
|
+
[...substitutions].map((entry) => [entry[0], renameLocals(entry[1], renamed)]),
|
|
510
524
|
),
|
|
511
525
|
variables: new Set(linked.variables),
|
|
512
526
|
getDefinition: (key) => definitions.get(key),
|
|
@@ -549,9 +563,14 @@ export const createEnvironment = (
|
|
|
549
563
|
instance.name === undefined
|
|
550
564
|
? standardSymbols
|
|
551
565
|
: new Map(
|
|
552
|
-
[...standardSymbols].map((
|
|
553
|
-
`${instance.name}!${
|
|
554
|
-
{
|
|
566
|
+
[...standardSymbols].map((entry) => [
|
|
567
|
+
`${instance.name}!${entry[0]}`,
|
|
568
|
+
{
|
|
569
|
+
key: entry[1].key,
|
|
570
|
+
arity: entry[1].arity,
|
|
571
|
+
params: entry[1].params,
|
|
572
|
+
kind: entry[1].kind,
|
|
573
|
+
},
|
|
555
574
|
]),
|
|
556
575
|
);
|
|
557
576
|
|
|
@@ -564,32 +583,34 @@ export const createEnvironment = (
|
|
|
564
583
|
const declared = new Set(declarations.map((declaration) => declaration.name));
|
|
565
584
|
return new Map(
|
|
566
585
|
[...exported]
|
|
567
|
-
.filter((
|
|
568
|
-
.map((
|
|
586
|
+
.filter((entry) => !declared.has(entry[0]))
|
|
587
|
+
.map((entry): [string, ModuleSymbol] => {
|
|
569
588
|
if (instance.name === undefined) {
|
|
570
589
|
return [
|
|
571
|
-
|
|
590
|
+
entry[0],
|
|
572
591
|
{
|
|
573
|
-
key: getKey(
|
|
574
|
-
arity:
|
|
575
|
-
params:
|
|
576
|
-
kind:
|
|
592
|
+
key: getKey(entry[1].key, entry[0]),
|
|
593
|
+
arity: entry[1].arity,
|
|
594
|
+
params: entry[1].params,
|
|
595
|
+
kind: entry[1].kind,
|
|
577
596
|
range:
|
|
578
|
-
parameterized.get(
|
|
597
|
+
parameterized.get(entry[1].key) === true
|
|
598
|
+
? instance.location.range
|
|
599
|
+
: entry[1].range,
|
|
579
600
|
},
|
|
580
601
|
];
|
|
581
602
|
}
|
|
582
|
-
const qualified = `${instance.name}!${
|
|
603
|
+
const qualified = `${instance.name}!${entry[0]}`;
|
|
583
604
|
return [
|
|
584
605
|
qualified,
|
|
585
606
|
{
|
|
586
|
-
key: getKey(
|
|
587
|
-
arity:
|
|
588
|
-
params:
|
|
607
|
+
key: getKey(entry[1].key, qualified),
|
|
608
|
+
arity: entry[1].arity + instance.params.length,
|
|
609
|
+
params: entry[1].params && [
|
|
589
610
|
...instance.params.map((param) => param.arity),
|
|
590
|
-
...
|
|
611
|
+
...entry[1].params,
|
|
591
612
|
],
|
|
592
|
-
kind:
|
|
613
|
+
kind: entry[1].kind,
|
|
593
614
|
},
|
|
594
615
|
];
|
|
595
616
|
}),
|
|
@@ -637,11 +658,11 @@ export const createEnvironment = (
|
|
|
637
658
|
const standardSymbols = nested ? undefined : getStandardSymbols(instance.module);
|
|
638
659
|
if (standardSymbols) {
|
|
639
660
|
if (instance.name === undefined) return [];
|
|
640
|
-
return [...standardSymbols].map((
|
|
641
|
-
const forwarded = createArgumentParams(
|
|
661
|
+
return [...standardSymbols].map((entry) => {
|
|
662
|
+
const forwarded = createArgumentParams(entry[1].arity, entry[1].params);
|
|
642
663
|
return createLocalAlias(
|
|
643
|
-
`${instance.name}!${
|
|
644
|
-
|
|
664
|
+
`${instance.name}!${entry[0]}`,
|
|
665
|
+
entry[1].key,
|
|
645
666
|
[...instance.params, ...forwarded],
|
|
646
667
|
forwarded,
|
|
647
668
|
location,
|
|
@@ -722,16 +743,16 @@ export const createEnvironment = (
|
|
|
722
743
|
});
|
|
723
744
|
const declared = new Set(declarations.map((declaration) => declaration.name));
|
|
724
745
|
const aliases = [...linked.exported]
|
|
725
|
-
.filter((
|
|
726
|
-
.map((
|
|
727
|
-
const key = instantiation.getKey(
|
|
728
|
-
const ownParams = createArgumentParams(
|
|
746
|
+
.filter((entry) => !declared.has(entry[0]))
|
|
747
|
+
.map((entry) => {
|
|
748
|
+
const key = instantiation.getKey(entry[1].key);
|
|
749
|
+
const ownParams = createArgumentParams(entry[1].arity, entry[1].params);
|
|
729
750
|
const params = [...instance.params, ...ownParams];
|
|
730
751
|
return createLocalAlias(
|
|
731
|
-
instance.name === undefined ?
|
|
752
|
+
instance.name === undefined ? entry[0] : `${instance.name}!${entry[0]}`,
|
|
732
753
|
key,
|
|
733
754
|
params,
|
|
734
|
-
key ===
|
|
755
|
+
key === entry[1].key ? ownParams : params,
|
|
735
756
|
location,
|
|
736
757
|
);
|
|
737
758
|
});
|
|
@@ -739,9 +760,9 @@ export const createEnvironment = (
|
|
|
739
760
|
};
|
|
740
761
|
|
|
741
762
|
const getAvailableDefinitions = (visible: Symbols) =>
|
|
742
|
-
[...visible].flatMap((
|
|
743
|
-
const definition = definitions.get(
|
|
744
|
-
return definition ? [{ ...definition, name }] : [];
|
|
763
|
+
[...visible].flatMap((entry) => {
|
|
764
|
+
const definition = definitions.get(entry[1].key);
|
|
765
|
+
return definition ? [{ ...definition, name: entry[0] }] : [];
|
|
745
766
|
});
|
|
746
767
|
|
|
747
768
|
const javaOverrides = new Map<string, JavaOverride[]>();
|
|
@@ -890,6 +911,13 @@ export const createEnvironment = (
|
|
|
890
911
|
module.definitions.toReversed().map((definition) => [definition.name, definition]),
|
|
891
912
|
),
|
|
892
913
|
getKey,
|
|
914
|
+
isModuleKnown: (name, location) =>
|
|
915
|
+
name === parsed.name ||
|
|
916
|
+
usedModules.has(name) ||
|
|
917
|
+
scope.modules.has(name) ||
|
|
918
|
+
parsed.modules.some(
|
|
919
|
+
(nested) => nested.name === name && isBefore(nested.location, location),
|
|
920
|
+
),
|
|
893
921
|
instanced,
|
|
894
922
|
facts,
|
|
895
923
|
reports,
|
|
@@ -910,7 +938,7 @@ export const createEnvironment = (
|
|
|
910
938
|
getDefinitionSymbol(definition),
|
|
911
939
|
]),
|
|
912
940
|
].reduce(
|
|
913
|
-
(symbols,
|
|
941
|
+
(symbols, entry) => (symbols.has(entry[0]) ? symbols : symbols.set(entry[0], entry[1])),
|
|
914
942
|
new Map(visible),
|
|
915
943
|
);
|
|
916
944
|
const linkNested = (nested: Module) => {
|
|
@@ -966,6 +994,13 @@ export const createEnvironment = (
|
|
|
966
994
|
),
|
|
967
995
|
getAvailableDefinitions(visible),
|
|
968
996
|
);
|
|
997
|
+
parsed.theorems
|
|
998
|
+
.flatMap((theorem) => getProofInstances(theorem.proof))
|
|
999
|
+
.filter((instance) => !getVisibleModules().has(instance.module))
|
|
1000
|
+
.forEach(
|
|
1001
|
+
(instance) =>
|
|
1002
|
+
getStandardSymbols(instance.module) ?? getLinkedModule(instance.module, parsed.name),
|
|
1003
|
+
);
|
|
969
1004
|
scope.errors.push(...resolveModule(module, getUnit(module)));
|
|
970
1005
|
module.definitions.forEach((definition) => {
|
|
971
1006
|
const key = getKey(definition);
|
|
@@ -1074,7 +1109,7 @@ export const createEnvironment = (
|
|
|
1074
1109
|
root: linkedRoot,
|
|
1075
1110
|
moduleSymbols: new Map([
|
|
1076
1111
|
...standardExports,
|
|
1077
|
-
...[...linkedModules].map((
|
|
1112
|
+
...[...linkedModules].map((entry): [string, Symbols] => [entry[0], entry[1].visible]),
|
|
1078
1113
|
[root.name, linkedRoot.visible],
|
|
1079
1114
|
]),
|
|
1080
1115
|
definitions,
|
|
@@ -1125,6 +1160,7 @@ export const createEnvironment = (
|
|
|
1125
1160
|
variableIndex,
|
|
1126
1161
|
facts,
|
|
1127
1162
|
startupValues: Array.from({ length: facts.ids.size }, (): Value | undefined => undefined),
|
|
1163
|
+
tlcEvalValues: new WeakMap(),
|
|
1128
1164
|
substitutedDefinitions,
|
|
1129
1165
|
instanceParams,
|
|
1130
1166
|
evaluators: new WeakMap(),
|
package/src/errors.ts
CHANGED
|
@@ -320,6 +320,13 @@ export class SmtTacticError extends TlaError {
|
|
|
320
320
|
}
|
|
321
321
|
}
|
|
322
322
|
|
|
323
|
+
export class SmtDefaultError extends TlaError {
|
|
324
|
+
constructor(message: string) {
|
|
325
|
+
super(message);
|
|
326
|
+
this.name = "SmtDefaultError";
|
|
327
|
+
}
|
|
328
|
+
}
|
|
329
|
+
|
|
323
330
|
export class SmtInvariantError extends TlaError {
|
|
324
331
|
constructor(message: string) {
|
|
325
332
|
super(message);
|