tla-ts 0.0.10-dev.37a75eb5b → 0.0.10-dev.45c0eaef5
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 +33 -33
- package/dist/deciders.js +53 -53
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +17 -3
- package/dist/index.d.ts +17 -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 +55 -55
- package/dist/prove.js +78 -78
- package/dist/run.cjs +40 -42
- package/dist/run.js +42 -44
- package/dist/tlapm.cjs +1 -1
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +96 -91
- package/dist/transfer.js +95 -90
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +31 -3
- package/src/bags.ts +12 -10
- package/src/builtins.ts +4 -3
- package/src/check-failure.ts +13 -11
- package/src/check-trace.ts +146 -93
- package/src/check.ts +418 -246
- package/src/cli/tlc-output.ts +17 -2
- package/src/cli/tlc.ts +5 -4
- package/src/cli/xml-exporter.ts +1 -1
- package/src/codegen.ts +23 -10
- package/src/coverage.ts +255 -18
- package/src/dependencies.ts +68 -15
- package/src/dfid.ts +93 -35
- package/src/environment.ts +106 -39
- package/src/errors.ts +7 -0
- package/src/evaluate.ts +415 -132
- package/src/exit-codes.ts +28 -15
- package/src/instances.ts +135 -11
- package/src/java-hash.ts +14 -0
- package/src/java-overrides.ts +2 -2
- package/src/levels.ts +674 -236
- package/src/lexer.ts +12 -2
- package/src/liveness-checker.ts +161 -60
- package/src/liveness.ts +55 -10
- 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 +110 -111
- 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 +164 -58
- package/src/prover/smt/solver/ast-lt.ts +1 -1
- package/src/prover/smt/solver/ast.ts +65 -13
- package/src/prover/smt/solver/auf-solver.ts +23 -12
- package/src/prover/smt/solver/bit-blast-tactic.ts +27 -1
- 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 +65 -14
- 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 +28 -16
- package/src/prover/smt/solver/diff-neq.ts +1 -2
- package/src/prover/smt/solver/dt2bv-tactic.ts +57 -21
- 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 +3 -9
- 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/fd-solver.ts +608 -141
- package/src/prover/smt/solver/fix-dl-var.ts +1 -2
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
- package/src/prover/smt/solver/goal.ts +4 -3
- 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 +15 -5
- package/src/prover/smt/solver/lp/core-solver.ts +12 -8
- package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
- package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
- package/src/prover/smt/solver/lp/nla-grobner.ts +2 -2
- 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 +14 -42
- 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 +1 -4
- 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 +4 -5
- package/src/prover/smt/solver/nlsat/levelwise.ts +0 -4
- package/src/prover/smt/solver/nlsat/polynomial.ts +1 -36
- package/src/prover/smt/solver/nlsat/upolynomial.ts +1 -1
- 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 +16 -7
- 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 +4 -3
- 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/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 +7 -3
- package/src/prover/smt/solver/sat/config.ts +1 -1
- package/src/prover/smt/solver/sat/goal2sat.ts +65 -12
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +129 -43
- package/src/prover/smt/solver/sat/model-converter.ts +1 -1
- package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
- package/src/prover/smt/solver/sat/sat-tactic.ts +15 -6
- package/src/prover/smt/solver/sat/sat2goal.ts +72 -48
- package/src/prover/smt/solver/sat/simplifier.ts +1 -1
- package/src/prover/smt/solver/sat/solver.ts +27 -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 +1 -1
- 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 +40 -6
- package/src/prover/smt/solver/smt-setup.ts +106 -13
- package/src/prover/smt/solver/smtlib-parser.ts +579 -214
- package/src/prover/smt/solver/smtlib-script.ts +600 -170
- 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 +342 -196
- 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-state.ts +1 -1
- 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/theory-without-terms.ts +24 -0
- 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 +1226 -246
- package/src/runtime.ts +19 -2
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +4 -2
- package/src/sany/generator-def-entries.ts +123 -36
- package/src/sany/generator-definitions.ts +4 -2
- package/src/sany/generator-expressions.ts +51 -20
- package/src/sany/generator-proofs.ts +17 -11
- package/src/sany/generator.ts +11 -5
- package/src/sany/lexer.ts +15 -7
- 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 +283 -126
- package/src/simulate.ts +247 -185
- package/src/spec-description.ts +15 -7
- package/src/standard-definitions.ts +1 -0
- package/src/standard-modules.ts +56 -22
- package/src/subexpressions.ts +563 -139
- package/src/successors.ts +50 -20
- package/src/symmetry.ts +2 -1
- package/src/tlc/jar-data.ts +1 -3
- package/src/tlc/messages.ts +3 -3
- package/src/tlc/random.ts +2 -1
- package/src/tlc/replay.ts +147 -46
- 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/trace-liveness.ts +529 -0
- package/src/typed-tier.ts +52 -31
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +150 -79
package/src/cli/tlc-output.ts
CHANGED
|
@@ -472,7 +472,11 @@ const printSuccess = (printer: MessagePrinter, optimistic: number, actual: numbe
|
|
|
472
472
|
].join("\n"),
|
|
473
473
|
);
|
|
474
474
|
|
|
475
|
-
export const printDepthFirst = (
|
|
475
|
+
export const printDepthFirst = (
|
|
476
|
+
printer: MessagePrinter,
|
|
477
|
+
output: DepthFirstOutput,
|
|
478
|
+
startTime: number,
|
|
479
|
+
) => {
|
|
476
480
|
switch (output.kind) {
|
|
477
481
|
case "message":
|
|
478
482
|
printer.print(
|
|
@@ -481,6 +485,9 @@ export const printDepthFirst = (printer: MessagePrinter, output: DepthFirstOutpu
|
|
|
481
485
|
printer.isTool ? output.toolMessage : output.message,
|
|
482
486
|
);
|
|
483
487
|
return;
|
|
488
|
+
case "coverage":
|
|
489
|
+
printCoverage(printer, output.coverage, startTime);
|
|
490
|
+
return;
|
|
484
491
|
case "behavior":
|
|
485
492
|
output.states.forEach((state, index) =>
|
|
486
493
|
output.isInvariant
|
|
@@ -548,6 +555,7 @@ export const printResult = (result: CheckResult, printer: MessagePrinter, timing
|
|
|
548
555
|
printTrace(printer, failure.trace, "error-trace");
|
|
549
556
|
const traceFailure = failure.traceFailure;
|
|
550
557
|
if (traceFailure) {
|
|
558
|
+
printTraceOutput(printer, traceFailure.output);
|
|
551
559
|
print(
|
|
552
560
|
traceFailure.code,
|
|
553
561
|
MESSAGE_LEVEL.error,
|
|
@@ -634,7 +642,11 @@ export const printStartupBanner = (printer: MessagePrinter, args: TlcArguments)
|
|
|
634
642
|
);
|
|
635
643
|
};
|
|
636
644
|
|
|
637
|
-
export const printSimulation = (
|
|
645
|
+
export const printSimulation = (
|
|
646
|
+
printer: MessagePrinter,
|
|
647
|
+
output: SimulationOutput,
|
|
648
|
+
startTime: number,
|
|
649
|
+
) => {
|
|
638
650
|
const print = printer.print;
|
|
639
651
|
switch (output.kind) {
|
|
640
652
|
case "message":
|
|
@@ -644,6 +656,9 @@ export const printSimulation = (printer: MessagePrinter, output: SimulationOutpu
|
|
|
644
656
|
printer.isTool ? output.toolMessage : output.message,
|
|
645
657
|
);
|
|
646
658
|
return;
|
|
659
|
+
case "coverage":
|
|
660
|
+
printCoverage(printer, output.coverage, startTime);
|
|
661
|
+
return;
|
|
647
662
|
case "behavior": {
|
|
648
663
|
const last = output.trace[output.trace.length - 1];
|
|
649
664
|
if (!output.isLastStateOnly) {
|
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 {
|
|
@@ -439,7 +440,7 @@ const checkSpec = async (
|
|
|
439
440
|
aril: args.aril,
|
|
440
441
|
isGenerating: args.mode === "generate",
|
|
441
442
|
scheduler: args.scheduler,
|
|
442
|
-
onSimulation: (output) => printSimulation(printer, output),
|
|
443
|
+
onSimulation: (output) => printSimulation(printer, output, timing.startTime),
|
|
443
444
|
});
|
|
444
445
|
printFinished();
|
|
445
446
|
return status;
|
|
@@ -448,7 +449,7 @@ const checkSpec = async (
|
|
|
448
449
|
const status = checkDepthFirst({
|
|
449
450
|
...options,
|
|
450
451
|
maxDepth: args.dfidDepth,
|
|
451
|
-
onOutput: (output) => printDepthFirst(printer, output),
|
|
452
|
+
onOutput: (output) => printDepthFirst(printer, output, timing.startTime),
|
|
452
453
|
});
|
|
453
454
|
printFinished();
|
|
454
455
|
return status;
|
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
|
@@ -1,4 +1,5 @@
|
|
|
1
1
|
import { getChildren, getReferencedName, isLocallyResolved, type Expression } from "./ast";
|
|
2
|
+
import { isTlcEvalReached } from "./dependencies";
|
|
2
3
|
import {
|
|
3
4
|
bindValue,
|
|
4
5
|
expectBooleanBody,
|
|
@@ -14,6 +15,7 @@ import {
|
|
|
14
15
|
getFunctionBuilder,
|
|
15
16
|
getLazyFilter,
|
|
16
17
|
isKeptLazy,
|
|
18
|
+
isUniformPredicate,
|
|
17
19
|
getDomainOperator,
|
|
18
20
|
getSubsetOperator,
|
|
19
21
|
getEvaluator,
|
|
@@ -161,19 +163,26 @@ const createLocal = (generator: Generator) => `local${generator.counter++}`;
|
|
|
161
163
|
const getFreeNames = (expression: Expression, names = new Set<string>()) => {
|
|
162
164
|
const name = getReferencedName(expression);
|
|
163
165
|
if (name !== undefined) names.add(name);
|
|
164
|
-
|
|
166
|
+
if (expression.kind !== "Selection") {
|
|
167
|
+
getChildren(expression).forEach((child) => getFreeNames(child, names));
|
|
168
|
+
}
|
|
165
169
|
return names;
|
|
166
170
|
};
|
|
167
171
|
|
|
168
172
|
const getDelegateContext = (generator: Generator, expression: Expression, frame: Frame) => {
|
|
173
|
+
if (frame.locals.size === 0) return frame.context;
|
|
174
|
+
// TLC caches a constant TLCEval only where no name is bound, so a delegate that reaches one sees every local.
|
|
175
|
+
const isEveryLocalCaptured = isTlcEvalReached(expression, generator.environment);
|
|
169
176
|
const freeNames = getFreeNames(expression);
|
|
170
|
-
const captured = [...frame.locals].filter(
|
|
177
|
+
const captured = [...frame.locals].filter(
|
|
178
|
+
(entry) => isEveryLocalCaptured || freeNames.has(entry[0]),
|
|
179
|
+
);
|
|
171
180
|
if (captured.length === 0) return frame.context;
|
|
172
181
|
const names = addReference(
|
|
173
182
|
generator,
|
|
174
|
-
captured.map((
|
|
183
|
+
captured.map((entry) => entry[0]),
|
|
175
184
|
);
|
|
176
|
-
return `extend(${frame.context}, ${names}, [${captured.map((
|
|
185
|
+
return `extend(${frame.context}, ${names}, [${captured.map((entry) => entry[1]).join(", ")}])`;
|
|
177
186
|
};
|
|
178
187
|
|
|
179
188
|
const generateDelegate = (generator: Generator, expression: Expression, frame: Frame) =>
|
|
@@ -267,7 +276,8 @@ const generateSetFilter = (
|
|
|
267
276
|
const lazy = `if (!isReducible(${base})) return ${filterLazily}(${base}, ${getDelegateContext(generator, expression, bodyFrame)});`;
|
|
268
277
|
const set = generateExpression(generator, expression.bound.set, bodyFrame);
|
|
269
278
|
bodyFrame.locals.set(name, element);
|
|
270
|
-
const
|
|
279
|
+
const stop = isUniformPredicate(expression, generator.environment) ? " else break;" : "";
|
|
280
|
+
const test = `if (filterPredicate(${generateExpression(generator, expression.predicate, bodyFrame)}, ${node})) addBounded(${kept}, ${element});${stop}`;
|
|
271
281
|
return `const ${base} = ${set}; ${lazy} const ${list} = ${base}.kind === "Interval" ? ${base} : finiteElements(${base}); const ${kept} = []; ${generateLoop(generator, list, element, test)} return normalizedSet(${kept});`;
|
|
272
282
|
});
|
|
273
283
|
|
|
@@ -318,9 +328,8 @@ const generateApply = (
|
|
|
318
328
|
const domain = addReference(generator, getDomainOperator(expression));
|
|
319
329
|
return `${domain}(${generateExpression(generator, args[0], frame)})`;
|
|
320
330
|
}
|
|
321
|
-
if (builtin.name === "
|
|
322
|
-
|
|
323
|
-
const subset = addReference(generator, getSubsetOperator(expression, builtin));
|
|
331
|
+
if (builtin.name === "\\subseteq" && builtin.evaluateBinary && args.length === 2) {
|
|
332
|
+
const subset = addReference(generator, getSubsetOperator(expression, builtin.evaluateBinary));
|
|
324
333
|
return `${subset}(${generateExpression(generator, args[0], frame)}, ${generateExpression(generator, args[1], frame)})`;
|
|
325
334
|
}
|
|
326
335
|
const environment = generator.environment;
|
|
@@ -440,12 +449,16 @@ const generateExpression = (generator: Generator, expression: Expression, frame:
|
|
|
440
449
|
generator,
|
|
441
450
|
fields.map((field) => field.name),
|
|
442
451
|
);
|
|
443
|
-
const values = `[${fields.map((field) => generate(field.value)).join(", ")}]`;
|
|
452
|
+
const values = `[${expression.fields.map((field) => generate(field.value)).join(", ")}]`;
|
|
444
453
|
const writtenNames = expression.fields.map((field) => field.name);
|
|
445
454
|
if (writtenNames.every((name, index) => name === fields[index].name)) {
|
|
446
455
|
return `record(${names}, ${values})`;
|
|
447
456
|
}
|
|
448
|
-
|
|
457
|
+
const writtenIndexes = addReference(
|
|
458
|
+
generator,
|
|
459
|
+
fields.map((field) => expression.fields.indexOf(field)),
|
|
460
|
+
);
|
|
461
|
+
return `writtenRecord(${names}, ${writtenIndexes}, ${values}, ${addReference(generator, writtenNames)})`;
|
|
449
462
|
}
|
|
450
463
|
case "Tuple":
|
|
451
464
|
return `tuple([${expression.elements.map((element) => generate(element)).join(", ")}])`;
|
package/src/coverage.ts
CHANGED
|
@@ -1,4 +1,5 @@
|
|
|
1
1
|
import {
|
|
2
|
+
getFunctionConstruction,
|
|
2
3
|
isLocallyResolved,
|
|
3
4
|
type Bound,
|
|
4
5
|
type Definition,
|
|
@@ -7,10 +8,17 @@ import {
|
|
|
7
8
|
type SourceRange,
|
|
8
9
|
} from "./ast";
|
|
9
10
|
import { formatRange } from "./errors";
|
|
11
|
+
import { SELECTION_NAME } from "./resolve";
|
|
10
12
|
import type { Environment, Scope } from "./evaluate";
|
|
11
13
|
import { getJavaHashCode } from "./java-hash";
|
|
12
14
|
import { getTlcFingerprint } from "./tlc/fingerprint";
|
|
13
|
-
import
|
|
15
|
+
import {
|
|
16
|
+
getCardinality,
|
|
17
|
+
isEmptySet,
|
|
18
|
+
isReducibleSet,
|
|
19
|
+
type IntervalValue,
|
|
20
|
+
type Value,
|
|
21
|
+
} from "./values";
|
|
14
22
|
|
|
15
23
|
export type CoverageKind = "init" | "next" | "invariant" | "constraint" | "implied";
|
|
16
24
|
|
|
@@ -49,6 +57,11 @@ export interface CoverageReport {
|
|
|
49
57
|
relations: CoverageRelationReport[];
|
|
50
58
|
}
|
|
51
59
|
|
|
60
|
+
export interface CoverageOutput {
|
|
61
|
+
kind: "coverage";
|
|
62
|
+
coverage: CoverageReport;
|
|
63
|
+
}
|
|
64
|
+
|
|
52
65
|
interface CoverageVariable {
|
|
53
66
|
label: string;
|
|
54
67
|
distinct: number;
|
|
@@ -81,6 +94,8 @@ interface Resolved {
|
|
|
81
94
|
scope: Local | undefined;
|
|
82
95
|
}
|
|
83
96
|
|
|
97
|
+
export const letDefinitions = new WeakMap<Scope, Definition>();
|
|
98
|
+
|
|
84
99
|
const STANDARD_MODULES = new Set([
|
|
85
100
|
"FiniteSets",
|
|
86
101
|
"Sequences",
|
|
@@ -118,6 +133,17 @@ export const createCoverage = (variableCount: number): Coverage => ({
|
|
|
118
133
|
relations: [],
|
|
119
134
|
});
|
|
120
135
|
|
|
136
|
+
export const createCoverageEnvironment = (
|
|
137
|
+
environment: Environment,
|
|
138
|
+
coverage: Coverage,
|
|
139
|
+
): Environment => ({
|
|
140
|
+
...environment,
|
|
141
|
+
evaluators: new WeakMap(),
|
|
142
|
+
entryEvaluators: new WeakMap(),
|
|
143
|
+
definitionEvaluators: new WeakMap(),
|
|
144
|
+
coverage,
|
|
145
|
+
});
|
|
146
|
+
|
|
121
147
|
const addNode = (
|
|
122
148
|
coverage: Coverage,
|
|
123
149
|
expression: Expression | undefined,
|
|
@@ -154,6 +180,10 @@ const findCoverageRelation = (coverage: Coverage, kind: CoverageKind, expression
|
|
|
154
180
|
(relation) => relation.kind === kind && relation.expression === expression,
|
|
155
181
|
)?.node;
|
|
156
182
|
|
|
183
|
+
const getRelationRange = (expression: Expression) =>
|
|
184
|
+
expression.location.range ??
|
|
185
|
+
(expression.kind === "Let" ? expression.body.location.range : undefined);
|
|
186
|
+
|
|
157
187
|
export const addCoverageRelation = (
|
|
158
188
|
coverage: Coverage,
|
|
159
189
|
kind: CoverageKind,
|
|
@@ -163,7 +193,7 @@ export const addCoverageRelation = (
|
|
|
163
193
|
) => {
|
|
164
194
|
const shared = kind === "next" ? findCoverageRelation(coverage, kind, expression) : undefined;
|
|
165
195
|
if (shared !== undefined) return shared;
|
|
166
|
-
const node = addNode(coverage, undefined, expression
|
|
196
|
+
const node = addNode(coverage, undefined, getRelationRange(expression), -1, false);
|
|
167
197
|
coverage.relations.push({ kind, label, expression, scope, node });
|
|
168
198
|
return node;
|
|
169
199
|
};
|
|
@@ -184,9 +214,9 @@ export const getCoverageLabel = (
|
|
|
184
214
|
) => {
|
|
185
215
|
const definition = name === undefined ? undefined : environment.definitions.get(name);
|
|
186
216
|
const head = definition?.kind === "Operator" ? definition.head : undefined;
|
|
187
|
-
const range = expression
|
|
217
|
+
const range = getRelationRange(expression);
|
|
188
218
|
if (!definition || !head) return `Action ${range ? formatRange(range) : "Unknown location"}`;
|
|
189
|
-
if (isSameRange(definition.body
|
|
219
|
+
if (isSameRange(getRelationRange(definition.body), range) || !range) {
|
|
190
220
|
return `${definition.name} ${formatRange(head)}`;
|
|
191
221
|
}
|
|
192
222
|
return `${definition.name} ${formatRange(head)} (${range.start.line} ${range.start.column} ${range.end.line} ${range.end.column})`;
|
|
@@ -233,6 +263,15 @@ const bindNames = (names: string[], locals: Local | undefined) =>
|
|
|
233
263
|
locals,
|
|
234
264
|
);
|
|
235
265
|
|
|
266
|
+
const bindLocalDefinitions = (definitions: Definition[], locals: Local | undefined) => {
|
|
267
|
+
const inner = definitions.reduce<Local | undefined>(
|
|
268
|
+
(parent, definition) => ({ name: definition.name, definition, scope: undefined, parent }),
|
|
269
|
+
locals,
|
|
270
|
+
);
|
|
271
|
+
for (let local = inner; local !== locals && local; local = local.parent) local.scope = inner;
|
|
272
|
+
return inner;
|
|
273
|
+
};
|
|
274
|
+
|
|
236
275
|
const getBoundNames = (bounds: Bound[]) =>
|
|
237
276
|
bounds.flatMap((bound) =>
|
|
238
277
|
bound.pattern.kind === "Name" ? [bound.pattern.name] : bound.pattern.names,
|
|
@@ -302,10 +341,13 @@ export const buildCoverage = (
|
|
|
302
341
|
definition.kind === "Function"
|
|
303
342
|
? getBoundNames(definition.bounds)
|
|
304
343
|
: definition.params.map((param) => param.name);
|
|
305
|
-
walk(definition.body, bindNames(names, resolved.scope));
|
|
306
344
|
if (definition.kind === "Function") {
|
|
307
|
-
|
|
308
|
-
|
|
345
|
+
const isLet = resolved.scope !== undefined;
|
|
346
|
+
enter(getFunctionConstruction(definition, isLet), definition.location.range, () => {
|
|
347
|
+
walk(definition.body, bindNames(names, resolved.scope));
|
|
348
|
+
getBoundSets(definition.bounds).forEach((set) => walk(set, resolved.scope));
|
|
349
|
+
});
|
|
350
|
+
} else walk(definition.body, bindNames(names, resolved.scope));
|
|
309
351
|
walking.pop();
|
|
310
352
|
};
|
|
311
353
|
|
|
@@ -380,20 +422,18 @@ export const buildCoverage = (
|
|
|
380
422
|
case "Lambda":
|
|
381
423
|
walk(expression.body, bindNames(expression.params, locals));
|
|
382
424
|
return;
|
|
425
|
+
case "Selection":
|
|
426
|
+
if (range === undefined) walk(expression.expression, locals);
|
|
427
|
+
else enter(expression, range, () => walk(expression.expression, locals));
|
|
428
|
+
return;
|
|
383
429
|
case "Let": {
|
|
384
|
-
const inner = expression.definitions
|
|
385
|
-
(parent, definition) => ({ name: definition.name, definition, scope: undefined, parent }),
|
|
386
|
-
locals,
|
|
387
|
-
);
|
|
388
|
-
for (let local = inner; local !== locals && local; local = local.parent) {
|
|
389
|
-
local.scope = inner;
|
|
390
|
-
}
|
|
430
|
+
const inner = bindLocalDefinitions(expression.definitions, locals);
|
|
391
431
|
expression.definitions.forEach((definition) => {
|
|
392
432
|
if (definition.kind === "Operator") letBodies.set(definition.body, expression.body);
|
|
393
433
|
});
|
|
394
|
-
getHashtableOrder(expression.definitions).forEach((definition) =>
|
|
395
|
-
walkDefinition({ definition, scope: inner })
|
|
396
|
-
);
|
|
434
|
+
getHashtableOrder(expression.definitions).forEach((definition) => {
|
|
435
|
+
if (definition.name !== SELECTION_NAME) walkDefinition({ definition, scope: inner });
|
|
436
|
+
});
|
|
397
437
|
walk(expression.body, inner);
|
|
398
438
|
return;
|
|
399
439
|
}
|
|
@@ -551,9 +591,18 @@ export const buildCoverage = (
|
|
|
551
591
|
}
|
|
552
592
|
};
|
|
553
593
|
|
|
594
|
+
const getScopeLocals = (scope: Scope | undefined) => {
|
|
595
|
+
const scoped: Definition[] = [];
|
|
596
|
+
for (let node = scope; node; node = node.parent) {
|
|
597
|
+
const definition = letDefinitions.get(node);
|
|
598
|
+
if (definition) scoped.unshift(definition);
|
|
599
|
+
}
|
|
600
|
+
return bindLocalDefinitions(scoped, undefined);
|
|
601
|
+
};
|
|
602
|
+
|
|
554
603
|
coverage.relations.forEach((relation) => {
|
|
555
604
|
stack.push(relation.node);
|
|
556
|
-
walk(relation.expression,
|
|
605
|
+
walk(relation.expression, getScopeLocals(relation.scope));
|
|
557
606
|
stack.pop();
|
|
558
607
|
});
|
|
559
608
|
};
|
|
@@ -602,6 +651,194 @@ export const costCoverage = (coverage: Coverage, value: Value, cost: number) =>
|
|
|
602
651
|
if (node !== undefined) coverage.secondary[node] += cost;
|
|
603
652
|
};
|
|
604
653
|
|
|
654
|
+
export const chargeSetOperation = (
|
|
655
|
+
coverage: Coverage,
|
|
656
|
+
operator: string,
|
|
657
|
+
left: Value,
|
|
658
|
+
right: Value,
|
|
659
|
+
result: Value,
|
|
660
|
+
): Value => {
|
|
661
|
+
const receiver = isReducibleSet(left)
|
|
662
|
+
? left
|
|
663
|
+
: operator !== "\\" && isReducibleSet(right)
|
|
664
|
+
? right
|
|
665
|
+
: undefined;
|
|
666
|
+
if (receiver === undefined || typeof result !== "object") return result;
|
|
667
|
+
const other = receiver === left ? right : left;
|
|
668
|
+
if (operator === "\\cup") {
|
|
669
|
+
if (isEmptySet(receiver) || !isReducibleSet(other)) return result;
|
|
670
|
+
const otherNode = coverage.values.get(other);
|
|
671
|
+
if (otherNode !== undefined) coverage.secondary[otherNode] += getCardinality(other) + 1;
|
|
672
|
+
}
|
|
673
|
+
const node = operator === "\\cup" ? undefined : coverage.values.get(receiver);
|
|
674
|
+
if (coverage.values.get(result) === node) return result;
|
|
675
|
+
const isShared = result === left || result === right || coverage.values.has(result);
|
|
676
|
+
const charged = isShared ? { ...result } : result;
|
|
677
|
+
if (node !== undefined) coverage.values.set(charged, node);
|
|
678
|
+
return charged;
|
|
679
|
+
};
|
|
680
|
+
|
|
681
|
+
interface ChargedEnumerator {
|
|
682
|
+
next: () => boolean;
|
|
683
|
+
reset: () => void;
|
|
684
|
+
}
|
|
685
|
+
|
|
686
|
+
const createListEnumerator = (coverage: Coverage, node: number | undefined, size: number) => {
|
|
687
|
+
let position = 0;
|
|
688
|
+
return {
|
|
689
|
+
next: () => {
|
|
690
|
+
if (node !== undefined) coverage.secondary[node]++;
|
|
691
|
+
return position++ < size;
|
|
692
|
+
},
|
|
693
|
+
reset: () => {
|
|
694
|
+
position = 0;
|
|
695
|
+
},
|
|
696
|
+
};
|
|
697
|
+
};
|
|
698
|
+
|
|
699
|
+
const createProductEnumerator = (
|
|
700
|
+
coverage: Coverage,
|
|
701
|
+
node: number,
|
|
702
|
+
sets: Value[],
|
|
703
|
+
): ChargedEnumerator => {
|
|
704
|
+
if (sets.some((set) => isEmptySet(set))) return { next: () => false, reset: () => undefined };
|
|
705
|
+
const enumerators = sets.map((set) =>
|
|
706
|
+
createEnumerator(coverage, set, getCardinality(set), false),
|
|
707
|
+
);
|
|
708
|
+
const advance = () => {
|
|
709
|
+
for (let index = enumerators.length - 1; index > 0; index--) {
|
|
710
|
+
if (enumerators[index].next()) return true;
|
|
711
|
+
enumerators[index].reset();
|
|
712
|
+
enumerators[index].next();
|
|
713
|
+
}
|
|
714
|
+
return enumerators.length > 0 && enumerators[0].next();
|
|
715
|
+
};
|
|
716
|
+
let isDone = !enumerators.every((enumerator) => enumerator.next());
|
|
717
|
+
return {
|
|
718
|
+
next: () => {
|
|
719
|
+
if (isDone) return false;
|
|
720
|
+
coverage.secondary[node] += Math.max(enumerators.length, 1);
|
|
721
|
+
isDone = !advance();
|
|
722
|
+
return true;
|
|
723
|
+
},
|
|
724
|
+
reset: () => {
|
|
725
|
+
enumerators.forEach((enumerator) => {
|
|
726
|
+
enumerator.reset();
|
|
727
|
+
enumerator.next();
|
|
728
|
+
});
|
|
729
|
+
isDone = false;
|
|
730
|
+
},
|
|
731
|
+
};
|
|
732
|
+
};
|
|
733
|
+
|
|
734
|
+
export const createProductSetEnumerator = (coverage: Coverage, set: Value) => {
|
|
735
|
+
const node = typeof set === "object" ? coverage.values.get(set) : undefined;
|
|
736
|
+
if (node === undefined || typeof set !== "object") return undefined;
|
|
737
|
+
if (set.kind === "RecordSet") return createProductEnumerator(coverage, node, set.sets);
|
|
738
|
+
if (set.kind !== "FunctionSet") return undefined;
|
|
739
|
+
return createProductEnumerator(
|
|
740
|
+
coverage,
|
|
741
|
+
node,
|
|
742
|
+
Array.from({ length: getCardinality(set.domain) }, () => set.range),
|
|
743
|
+
);
|
|
744
|
+
};
|
|
745
|
+
|
|
746
|
+
const createEnumerator = (
|
|
747
|
+
coverage: Coverage,
|
|
748
|
+
set: Value,
|
|
749
|
+
size: number,
|
|
750
|
+
isNormalized: boolean,
|
|
751
|
+
): ChargedEnumerator => {
|
|
752
|
+
const node = typeof set === "object" ? coverage.values.get(set) : undefined;
|
|
753
|
+
if (
|
|
754
|
+
typeof set === "object" &&
|
|
755
|
+
(set.kind === "Subset" || (!isNormalized && set.kind === "FilteredSet"))
|
|
756
|
+
) {
|
|
757
|
+
return createListEnumerator(coverage, undefined, size);
|
|
758
|
+
}
|
|
759
|
+
const elements = createProductSetEnumerator(coverage, set);
|
|
760
|
+
if (!elements || node === undefined) return createListEnumerator(coverage, node, size);
|
|
761
|
+
if (!isNormalized) return elements;
|
|
762
|
+
let count = 0;
|
|
763
|
+
while (elements.next()) count++;
|
|
764
|
+
coverage.secondary[node] += count;
|
|
765
|
+
return createListEnumerator(coverage, node, count);
|
|
766
|
+
};
|
|
767
|
+
|
|
768
|
+
export const tagSubset = (coverage: Coverage, set: Value, subset: Value) => {
|
|
769
|
+
const node =
|
|
770
|
+
typeof set === "object" && set.kind === "Subset" ? coverage.values.get(set) : undefined;
|
|
771
|
+
if (node !== undefined && typeof subset === "object") coverage.values.set(subset, node);
|
|
772
|
+
};
|
|
773
|
+
|
|
774
|
+
const RANDOMLY_INDEXED_KINDS = new Set<string>([
|
|
775
|
+
"Set",
|
|
776
|
+
"MixedSet",
|
|
777
|
+
"Interval",
|
|
778
|
+
"FunctionSet",
|
|
779
|
+
"RecordSet",
|
|
780
|
+
"ProductSet",
|
|
781
|
+
]);
|
|
782
|
+
|
|
783
|
+
// TLC's EnumerableValue#elements(Ordering.RANDOMIZED) draws indices, but a value class without its own k-out-of-n enumerator draws the whole set first, and SubsetValue converts itself to a SetEnumValue.
|
|
784
|
+
export const chargeRandomOrder = (coverage: Coverage, set: Value, size: number, order: Value[]) => {
|
|
785
|
+
if (typeof set !== "object" || RANDOMLY_INDEXED_KINDS.has(set.kind)) return;
|
|
786
|
+
if (set.kind !== "Subset") {
|
|
787
|
+
const enumerator = createEnumerator(coverage, set, size, false);
|
|
788
|
+
for (let position = 0; position <= size; position++) enumerator.next();
|
|
789
|
+
return;
|
|
790
|
+
}
|
|
791
|
+
const node = coverage.values.get(set);
|
|
792
|
+
if (node !== undefined) coverage.secondary[node] += size;
|
|
793
|
+
for (let position = 0; position < order.length; position++) {
|
|
794
|
+
tagSubset(coverage, set, order[position]);
|
|
795
|
+
}
|
|
796
|
+
};
|
|
797
|
+
|
|
798
|
+
export const createChargedEnumerator = (
|
|
799
|
+
coverage: Coverage,
|
|
800
|
+
set: Value,
|
|
801
|
+
list: Value[] | IntervalValue,
|
|
802
|
+
isNormalized: boolean,
|
|
803
|
+
) => {
|
|
804
|
+
const size = Array.isArray(list) ? list.length : list.high - list.low + 1;
|
|
805
|
+
if (typeof set !== "object" || set.kind !== "Subset" || !Array.isArray(list)) {
|
|
806
|
+
return createEnumerator(coverage, set, size, isNormalized);
|
|
807
|
+
}
|
|
808
|
+
list.forEach((subset) => tagSubset(coverage, set, subset));
|
|
809
|
+
return createListEnumerator(coverage, undefined, size);
|
|
810
|
+
};
|
|
811
|
+
|
|
812
|
+
const chargeBindings = (enumerators: ChargedEnumerator[]) => {
|
|
813
|
+
enumerators.every((enumerator) => enumerator.next());
|
|
814
|
+
return () => {
|
|
815
|
+
for (let index = 0; index < enumerators.length; index++) {
|
|
816
|
+
if (enumerators[index].next() || index === enumerators.length - 1) return;
|
|
817
|
+
enumerators[index].reset();
|
|
818
|
+
enumerators[index].next();
|
|
819
|
+
}
|
|
820
|
+
};
|
|
821
|
+
};
|
|
822
|
+
|
|
823
|
+
export const chargeContexts = (
|
|
824
|
+
coverage: Coverage,
|
|
825
|
+
sets: Value[],
|
|
826
|
+
lists: (Value[] | IntervalValue)[],
|
|
827
|
+
) =>
|
|
828
|
+
chargeBindings(
|
|
829
|
+
sets.map((set, index) => createChargedEnumerator(coverage, set, lists[index], true)),
|
|
830
|
+
);
|
|
831
|
+
|
|
832
|
+
export const chargeFunctionConstruction = (coverage: Coverage, node: number, sets: Value[]) => {
|
|
833
|
+
const sizes = sets.map((set) => getCardinality(set));
|
|
834
|
+
const advance = chargeBindings(
|
|
835
|
+
sets.map((set, index) => createEnumerator(coverage, set, sizes[index], false)),
|
|
836
|
+
);
|
|
837
|
+
const size = sizes.reduce((product, setSize) => product * setSize, 1);
|
|
838
|
+
for (let index = 0; index < size; index++) advance();
|
|
839
|
+
coverage.secondary[node] += size;
|
|
840
|
+
};
|
|
841
|
+
|
|
605
842
|
const getLeadingZeros = (value: bigint) => {
|
|
606
843
|
const high = Number(value >> 32n);
|
|
607
844
|
return high === 0 ? 32 + Math.clz32(Number(value & 0xffffffffn)) : Math.clz32(high);
|