tla-ts 0.0.10-dev.f16792fed → 0.0.10-dev.fdc173479
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/README.md +2 -1
- package/dist/compile.cjs +6 -6
- package/dist/compile.js +10 -10
- package/dist/deciders.cjs +41 -37
- package/dist/deciders.js +41 -37
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +21 -4
- package/dist/index.d.ts +21 -4
- 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 +2681 -425
- package/dist/prove.js +2681 -425
- package/dist/run.cjs +41 -42
- package/dist/run.js +41 -42
- package/dist/tlapm.cjs +2 -2
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +97 -89
- package/dist/transfer.js +97 -89
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +72 -39
- package/src/bags.ts +50 -29
- package/src/builtins.ts +8 -16
- package/src/check-failure.ts +118 -0
- package/src/check-trace.ts +321 -0
- package/src/check.ts +828 -770
- package/src/cli/options.ts +6 -31
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/shared.ts +1 -1
- package/src/cli/tlapm.ts +433 -70
- package/src/cli/tlc-arguments.ts +224 -212
- package/src/cli/tlc-output.ts +701 -0
- package/src/cli/tlc-usage.ts +1 -2
- package/src/cli/tlc.ts +65 -712
- package/src/cli/xml-exporter.ts +23 -33
- package/src/codegen.ts +28 -20
- package/src/coverage.ts +255 -20
- package/src/dependencies.ts +96 -27
- package/src/dfid.ts +115 -50
- package/src/environment-config.ts +315 -0
- package/src/environment.ts +175 -373
- package/src/errors.ts +40 -5
- package/src/evaluate.ts +429 -139
- package/src/exit-codes.ts +28 -12
- package/src/fingerprints.ts +65 -1
- package/src/instances.ts +178 -17
- package/src/java-hash.ts +14 -0
- package/src/java-overrides.ts +2 -2
- package/src/json.ts +4 -7
- package/src/levels.ts +708 -272
- package/src/lexer.ts +17 -5
- package/src/liveness-checker.ts +707 -249
- package/src/liveness.ts +148 -95
- package/src/obligations/action.ts +14 -17
- package/src/obligations/anonymize.ts +37 -16
- package/src/obligations/enabled-axioms.ts +218 -0
- package/src/obligations/equality.ts +1 -3
- package/src/obligations/expression.ts +36 -8
- package/src/obligations/format.ts +0 -2
- package/src/obligations/generate.ts +66 -54
- package/src/obligations/index.ts +39 -9
- package/src/obligations/levels.ts +24 -11
- package/src/obligations/module.ts +28 -41
- package/src/obligations/normalize.ts +27 -18
- package/src/obligations/operators.ts +0 -2
- package/src/obligations/pragma.ts +53 -16
- package/src/obligations/printer.ts +48 -18
- package/src/obligations/proof.ts +3 -2
- package/src/obligations/regroup.ts +0 -2
- package/src/obligations/simplify.ts +55 -50
- package/src/obligations/source.ts +120 -74
- package/src/obligations/subexpression.ts +45 -18
- package/src/obligations/substitution.ts +1 -3
- package/src/obligations/temporal.ts +5 -7
- package/src/obligations/tuples.ts +0 -2
- package/src/parallel-worker.ts +17 -31
- package/src/parallel.ts +29 -47
- package/src/parser.ts +757 -326
- package/src/pretty-print.ts +1 -1
- package/src/prover/decide-pool.ts +3 -3
- package/src/prover/deciders.ts +12 -9
- package/src/prover/isabelle/decide.ts +3 -25
- package/src/prover/isabelle/encode.ts +72 -42
- package/src/prover/isabelle/isar/attrib.ts +250 -0
- package/src/prover/isabelle/isar/context.ts +335 -0
- package/src/prover/isabelle/isar/induct.ts +382 -0
- package/src/prover/isabelle/isar/inner-syntax.ts +158 -7
- package/src/prover/isabelle/isar/method.ts +509 -212
- package/src/prover/isabelle/isar/proof.ts +570 -14
- package/src/prover/isabelle/isar/rule-cases.ts +226 -0
- package/src/prover/isabelle/isar/theory.ts +487 -76
- package/src/prover/isabelle/isar/toplevel.ts +331 -0
- package/src/prover/isabelle/isar/type-check.ts +89 -14
- package/src/prover/isabelle/provers/blast/blast.ts +7 -65
- package/src/prover/isabelle/provers/blast/branch.ts +0 -2
- package/src/prover/isabelle/provers/blast/prove.ts +0 -2
- package/src/prover/isabelle/provers/blast/rules.ts +0 -2
- package/src/prover/isabelle/provers/blast/state.ts +0 -2
- package/src/prover/isabelle/provers/blast/term.ts +0 -2
- package/src/prover/isabelle/provers/clasimp.ts +1 -3
- package/src/prover/isabelle/provers/classical.ts +45 -20
- package/src/prover/isabelle/provers/hypsubst.ts +19 -30
- package/src/prover/isabelle/pure/bicompose.ts +9 -27
- package/src/prover/isabelle/pure/consts.ts +0 -2
- package/src/prover/isabelle/pure/conv.ts +2 -10
- package/src/prover/isabelle/pure/drule.ts +72 -6
- package/src/prover/isabelle/pure/envir.ts +0 -2
- package/src/prover/isabelle/pure/goal.ts +1 -3
- package/src/prover/isabelle/pure/logic.ts +1 -3
- package/src/prover/isabelle/pure/name.ts +0 -2
- package/src/prover/isabelle/pure/net.ts +0 -2
- package/src/prover/isabelle/pure/object-logic.ts +13 -7
- package/src/prover/isabelle/pure/pattern.ts +0 -2
- package/src/prover/isabelle/pure/raw-simplifier.ts +4 -15
- package/src/prover/isabelle/pure/rewriter.ts +9 -20
- package/src/prover/isabelle/pure/search.ts +0 -2
- package/src/prover/isabelle/pure/seq.ts +0 -2
- package/src/prover/isabelle/pure/simplifier.ts +26 -7
- package/src/prover/isabelle/pure/table.ts +2 -3
- package/src/prover/isabelle/pure/tactic.ts +0 -2
- package/src/prover/isabelle/pure/tactical.ts +42 -37
- package/src/prover/isabelle/pure/term-ord.ts +0 -2
- package/src/prover/isabelle/pure/term.ts +3 -5
- package/src/prover/isabelle/pure/thm.ts +14 -13
- package/src/prover/isabelle/pure/type.ts +0 -2
- package/src/prover/isabelle/pure/unify.ts +0 -2
- package/src/prover/isabelle/pure/variable.ts +0 -2
- package/src/prover/isabelle/tla/classical-setup.ts +18 -16
- package/src/prover/isabelle/tla/context.ts +58 -11
- package/src/prover/isabelle/tla/logic-data.ts +1 -1
- package/src/prover/isabelle/tla/logic.ts +49 -21
- package/src/prover/isabelle/tla/simpdata.ts +1 -12
- package/src/prover/isabelle/tools/intuitionistic.ts +28 -12
- package/src/prover/ocaml.ts +4 -1
- package/src/prover/prep/action.ts +30 -31
- package/src/prover/prep/enabled-axioms.ts +11 -2
- package/src/prover/prep/fingerprint.ts +2 -5
- package/src/prover/prep/md5.ts +26 -29
- package/src/prover/prep/methods.ts +181 -51
- package/src/prover/prep/normalize.ts +38 -9
- package/src/prover/prove.ts +395 -94
- package/src/prover/ptl/decide.ts +95 -50
- package/src/prover/ptl/encode.ts +2 -3
- package/src/prover/ptl/tableau.ts +28 -2
- package/src/prover/smt/arithmetic.ts +310 -0
- package/src/prover/smt/axioms.ts +12 -8
- package/src/prover/smt/context.ts +43 -8
- package/src/prover/smt/data.ts +498 -379
- package/src/prover/smt/encode.ts +148 -57
- package/src/prover/smt/extensionality.ts +5 -3
- package/src/prover/smt/flatten.ts +4 -6
- package/src/prover/smt/format.ts +28 -4
- package/src/prover/smt/instances.ts +7 -1
- package/src/prover/smt/layout.ts +91 -0
- package/src/prover/smt/rewrite.ts +1016 -618
- package/src/prover/smt/simplify.ts +441 -0
- package/src/prover/smt/solver/ackermannize-bv-tactic.ts +62 -0
- package/src/prover/smt/solver/ackr-helper.ts +179 -0
- package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
- package/src/prover/smt/solver/act-cache.ts +0 -1
- package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
- package/src/prover/smt/solver/aig-tactic.ts +52 -0
- package/src/prover/smt/solver/aig.ts +889 -0
- package/src/prover/smt/solver/arith-rewriter.ts +624 -9
- package/src/prover/smt/solver/arith-terms.ts +121 -0
- package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
- package/src/prover/smt/solver/array-rewriter.ts +319 -0
- package/src/prover/smt/solver/asserted-formulas.ts +240 -56
- package/src/prover/smt/solver/ast-lt.ts +165 -11
- package/src/prover/smt/solver/ast-util.ts +160 -2
- package/src/prover/smt/solver/ast.ts +1483 -45
- package/src/prover/smt/solver/auf-solver.ts +25 -18
- package/src/prover/smt/solver/bit-blast-tactic.ts +608 -0
- package/src/prover/smt/solver/bit-blaster.ts +871 -0
- package/src/prover/smt/solver/blast-term-ite.ts +47 -0
- package/src/prover/smt/solver/bound-manager.ts +196 -0
- package/src/prover/smt/solver/bound-simplifier.ts +598 -0
- package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
- package/src/prover/smt/solver/bv-decl-plugin.ts +341 -0
- package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
- package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
- package/src/prover/smt/solver/bv1-blast.ts +214 -0
- package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
- package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
- package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
- package/src/prover/smt/solver/card2bv.ts +127 -0
- package/src/prover/smt/solver/case-split-queue.ts +0 -2
- package/src/prover/smt/solver/cg-table.ts +39 -25
- package/src/prover/smt/solver/check-logic.ts +330 -0
- package/src/prover/smt/solver/clause.ts +0 -1
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +293 -0
- package/src/prover/smt/solver/conflict-resolution.ts +78 -2
- package/src/prover/smt/solver/context.ts +598 -128
- package/src/prover/smt/solver/ctx-simplify.ts +29 -14
- package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
- package/src/prover/smt/solver/datatype-decl-plugin.ts +580 -0
- package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
- package/src/prover/smt/solver/demodulator.ts +786 -0
- package/src/prover/smt/solver/dependent-expr-state.ts +93 -0
- package/src/prover/smt/solver/der.ts +38 -10
- package/src/prover/smt/solver/diff-neq.ts +207 -0
- package/src/prover/smt/solver/distribute-forall.ts +57 -0
- package/src/prover/smt/solver/dom-simplify.ts +511 -0
- package/src/prover/smt/solver/dt2bv-tactic.ts +298 -0
- package/src/prover/smt/solver/dyn-ack.ts +0 -1
- package/src/prover/smt/solver/e-matching.ts +7 -8
- package/src/prover/smt/solver/elim-bounds.ts +89 -0
- package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
- package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +548 -0
- package/src/prover/smt/solver/enode.ts +100 -3
- package/src/prover/smt/solver/eq2bv-tactic.ts +227 -0
- package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
- package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
- package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
- package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
- package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
- package/src/prover/smt/solver/euf/array-solver.ts +306 -0
- package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
- package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
- package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
- package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
- package/src/prover/smt/solver/euf/egraph.ts +901 -0
- package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
- package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
- package/src/prover/smt/solver/euf/mam.ts +1046 -0
- package/src/prover/smt/solver/euf/q-ematch.ts +829 -0
- package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
- package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
- package/src/prover/smt/solver/euf/q-solver.ts +361 -0
- package/src/prover/smt/solver/euf/th-solver.ts +328 -0
- package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
- package/src/prover/smt/solver/expr-ref.ts +0 -1
- package/src/prover/smt/solver/expr-safe-replace.ts +26 -2
- package/src/prover/smt/solver/expr2polynomial.ts +271 -0
- package/src/prover/smt/solver/factor.ts +163 -0
- package/src/prover/smt/solver/fd-solver.ts +734 -0
- package/src/prover/smt/solver/fingerprints.ts +15 -15
- package/src/prover/smt/solver/fix-dl-var.ts +147 -0
- package/src/prover/smt/solver/flat-literals.ts +0 -1
- package/src/prover/smt/solver/fm-tactic.ts +886 -0
- package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
- package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
- package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
- package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
- package/src/prover/smt/solver/goal.ts +178 -15
- package/src/prover/smt/solver/goal2nlsat.ts +216 -0
- package/src/prover/smt/solver/guard-set.ts +219 -0
- package/src/prover/smt/solver/hash.ts +0 -1
- package/src/prover/smt/solver/hashtable.ts +34 -16
- package/src/prover/smt/solver/inf-eps.ts +63 -0
- package/src/prover/smt/solver/inj-axiom.ts +101 -0
- package/src/prover/smt/solver/internalizer.ts +111 -39
- package/src/prover/smt/solver/lackr.ts +381 -0
- package/src/prover/smt/solver/lbool.ts +0 -1
- package/src/prover/smt/solver/lia2card.ts +268 -0
- package/src/prover/smt/solver/lia2pb.ts +154 -0
- package/src/prover/smt/solver/literal.ts +0 -1
- package/src/prover/smt/solver/logic-tactics.ts +355 -0
- package/src/prover/smt/solver/lp/bound-propagator.ts +0 -1
- package/src/prover/smt/solver/lp/constraints.ts +0 -1
- package/src/prover/smt/solver/lp/containers.ts +7 -2
- package/src/prover/smt/solver/lp/core-solver.ts +30 -11
- package/src/prover/smt/solver/lp/cross-nested.ts +1 -4
- package/src/prover/smt/solver/lp/dep-intervals.ts +0 -3
- package/src/prover/smt/solver/lp/dependency.ts +0 -2
- package/src/prover/smt/solver/lp/dioph-eq.ts +1 -10
- package/src/prover/smt/solver/lp/explanation.ts +0 -1
- package/src/prover/smt/solver/lp/gomory.ts +0 -1
- package/src/prover/smt/solver/lp/hnf-cutter.ts +1 -2
- package/src/prover/smt/solver/lp/hnf.ts +0 -3
- package/src/prover/smt/solver/lp/int-cube.ts +3 -4
- package/src/prover/smt/solver/lp/int-solver.ts +0 -2
- package/src/prover/smt/solver/lp/lar-solver.ts +41 -5
- package/src/prover/smt/solver/lp/lar-term.ts +0 -1
- package/src/prover/smt/solver/lp/lp-settings.ts +6 -3
- package/src/prover/smt/solver/lp/maximize-term.ts +59 -10
- package/src/prover/smt/solver/lp/nex-creator.ts +3 -3
- package/src/prover/smt/solver/lp/nex.ts +2 -2
- package/src/prover/smt/solver/lp/nla-backoff.ts +0 -2
- package/src/prover/smt/solver/lp/nla-basics.ts +46 -3
- package/src/prover/smt/solver/lp/nla-core.ts +68 -17
- package/src/prover/smt/solver/lp/nla-divisions.ts +0 -2
- package/src/prover/smt/solver/lp/nla-emonics.ts +0 -1
- package/src/prover/smt/solver/lp/nla-factorization.ts +0 -1
- package/src/prover/smt/solver/lp/nla-grobner.ts +167 -85
- package/src/prover/smt/solver/lp/nla-horner.ts +0 -2
- package/src/prover/smt/solver/lp/nla-intervals.ts +0 -1
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +0 -2
- package/src/prover/smt/solver/lp/nla-monotone.ts +0 -1
- package/src/prover/smt/solver/lp/nla-order.ts +0 -2
- package/src/prover/smt/solver/lp/nla-patcher.ts +0 -1
- package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
- package/src/prover/smt/solver/lp/nla-tangents.ts +0 -2
- package/src/prover/smt/solver/lp/nla-throttle.ts +0 -1
- package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
- package/src/prover/smt/solver/lp/nla-types.ts +0 -2
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +0 -1
- package/src/prover/smt/solver/lp/nra-solver.ts +163 -99
- package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
- package/src/prover/smt/solver/lp/pdd-interval.ts +6 -3
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -21
- package/src/prover/smt/solver/lp/pdd-solver.ts +72 -41
- package/src/prover/smt/solver/lp/pdd.ts +725 -290
- package/src/prover/smt/solver/lp/random-updater.ts +0 -2
- package/src/prover/smt/solver/lp/static-matrix.ts +0 -1
- package/src/prover/smt/solver/lp/union-find.ts +7 -2
- package/src/prover/smt/solver/macro-finder.ts +530 -0
- package/src/prover/smt/solver/mam-compiler.ts +122 -90
- package/src/prover/smt/solver/mam-interpreter.ts +0 -1
- package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
- package/src/prover/smt/solver/max-cliques.ts +105 -0
- package/src/prover/smt/solver/maxcore.ts +310 -0
- package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -6
- package/src/prover/smt/solver/maxlex.ts +115 -0
- package/src/prover/smt/solver/maxsmt-base.ts +106 -0
- package/src/prover/smt/solver/maxsmt.ts +92 -0
- package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
- package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
- package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
- package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
- package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
- package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
- package/src/prover/smt/solver/model-based-opt.ts +844 -0
- package/src/prover/smt/solver/model-checker.ts +19 -28
- package/src/prover/smt/solver/model-evaluator.ts +190 -12
- package/src/prover/smt/solver/model-finder.ts +12 -18
- package/src/prover/smt/solver/model-generator.ts +104 -35
- package/src/prover/smt/solver/model-macro-solver.ts +49 -46
- package/src/prover/smt/solver/model-printer.ts +214 -0
- package/src/prover/smt/solver/mpf.ts +709 -0
- package/src/prover/smt/solver/mus.ts +50 -0
- package/src/prover/smt/solver/muz/dl-context.ts +382 -0
- package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
- package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
- package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
- package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
- package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
- package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
- package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
- package/src/prover/smt/solver/muz/dl-rule.ts +495 -0
- package/src/prover/smt/solver/muz/hnf.ts +201 -0
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
- package/src/prover/smt/solver/muz/horn-tactic.ts +214 -0
- package/src/prover/smt/solver/muz/rule-properties.ts +359 -0
- package/src/prover/smt/solver/muz/spacer-context.ts +1404 -0
- package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
- package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
- package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
- package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
- package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
- package/src/prover/smt/solver/muz/substitution.ts +203 -0
- package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
- package/src/prover/smt/solver/nlqsat.ts +485 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +315 -98
- package/src/prover/smt/solver/nlsat/atoms.ts +71 -38
- package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
- package/src/prover/smt/solver/nlsat/explain.ts +427 -229
- package/src/prover/smt/solver/nlsat/interval-set.ts +1 -2
- package/src/prover/smt/solver/nlsat/levelwise.ts +460 -246
- package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
- package/src/prover/smt/solver/nlsat/polynomial.ts +2376 -684
- package/src/prover/smt/solver/nlsat/solver.ts +293 -92
- package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
- package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
- package/src/prover/smt/solver/nlsat/types.ts +0 -2
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +9 -8
- package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -20
- package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
- package/src/prover/smt/solver/nnf.ts +110 -24
- package/src/prover/smt/solver/normalize-bounds.ts +53 -0
- package/src/prover/smt/solver/occf.ts +97 -0
- package/src/prover/smt/solver/opt-context.ts +801 -0
- package/src/prover/smt/solver/opt-nlsat.ts +386 -0
- package/src/prover/smt/solver/opt-pareto.ts +301 -0
- package/src/prover/smt/solver/opt-preprocess.ts +101 -0
- package/src/prover/smt/solver/opt-solver.ts +312 -0
- package/src/prover/smt/solver/opt-value.ts +55 -0
- package/src/prover/smt/solver/optsmt.ts +692 -0
- package/src/prover/smt/solver/parallel-tactic.ts +299 -0
- package/src/prover/smt/solver/pattern-inference.ts +19 -11
- package/src/prover/smt/solver/pb-rewriter.ts +281 -0
- package/src/prover/smt/solver/pb2bv-tactic.ts +546 -0
- package/src/prover/smt/solver/poly-rewriter.ts +259 -57
- package/src/prover/smt/solver/probes.ts +577 -0
- package/src/prover/smt/solver/propagate-values.ts +37 -21
- package/src/prover/smt/solver/proto-model.ts +648 -19
- package/src/prover/smt/solver/pull-quant.ts +28 -12
- package/src/prover/smt/solver/purify-arith.ts +634 -0
- package/src/prover/smt/solver/push-app-ite.ts +37 -0
- package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -0
- package/src/prover/smt/solver/qe-lite-der.ts +2 -3
- package/src/prover/smt/solver/qe-lite-fm.ts +3 -4
- package/src/prover/smt/solver/qe-lite.ts +39 -19
- package/src/prover/smt/solver/qe-mbp.ts +270 -0
- package/src/prover/smt/solver/qe.ts +1499 -0
- package/src/prover/smt/solver/qel.ts +25 -0
- package/src/prover/smt/solver/qi-queue.ts +0 -1
- package/src/prover/smt/solver/qsat.ts +829 -0
- package/src/prover/smt/solver/quant-hoist.ts +196 -0
- package/src/prover/smt/solver/quant-tactics.ts +16 -56
- package/src/prover/smt/solver/quantifier-analyzer.ts +19 -20
- package/src/prover/smt/solver/quantifier-manager.ts +22 -25
- package/src/prover/smt/solver/quasi-macros.ts +243 -0
- package/src/prover/smt/solver/random-gen.ts +0 -1
- package/src/prover/smt/solver/rational.ts +45 -1
- package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -0
- package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
- package/src/prover/smt/solver/reduce-args.ts +225 -0
- package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
- package/src/prover/smt/solver/ref-vector.ts +0 -1
- package/src/prover/smt/solver/relevancy.ts +1 -2
- package/src/prover/smt/solver/rewriter-tpl.ts +82 -14
- package/src/prover/smt/solver/rewriter.ts +505 -60
- package/src/prover/smt/solver/rlimit.ts +45 -5
- package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
- package/src/prover/smt/solver/sat/big.ts +177 -0
- package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
- package/src/prover/smt/solver/sat/clause.ts +203 -0
- package/src/prover/smt/solver/sat/cleaner.ts +94 -0
- package/src/prover/smt/solver/sat/config.ts +122 -0
- package/src/prover/smt/solver/sat/consequences.ts +203 -0
- package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
- package/src/prover/smt/solver/sat/goal2sat.ts +589 -0
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +480 -0
- package/src/prover/smt/solver/sat/model-converter.ts +136 -0
- package/src/prover/smt/solver/sat/pb-constraint.ts +268 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +1596 -0
- package/src/prover/smt/solver/sat/probing.ts +170 -0
- package/src/prover/smt/solver/sat/sat-tactic.ts +72 -0
- package/src/prover/smt/solver/sat/sat2goal.ts +190 -0
- package/src/prover/smt/solver/sat/scc.ts +142 -0
- package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
- package/src/prover/smt/solver/sat/solver.ts +2107 -0
- package/src/prover/smt/solver/sat/var-queue.ts +117 -0
- package/src/prover/smt/solver/sat/watch-list.ts +140 -0
- package/src/prover/smt/solver/search-tree.ts +284 -0
- package/src/prover/smt/solver/seq-axioms.ts +995 -0
- package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
- package/src/prover/smt/solver/seq-derive.ts +1298 -0
- package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
- package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
- package/src/prover/smt/solver/seq-factory.ts +89 -0
- package/src/prover/smt/solver/seq-monadic.ts +730 -0
- package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
- package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -0
- package/src/prover/smt/solver/seq-re-util.ts +758 -0
- package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
- package/src/prover/smt/solver/seq-regex-live.ts +200 -0
- package/src/prover/smt/solver/seq-rewriter.ts +2404 -0
- package/src/prover/smt/solver/seq-skolem.ts +294 -0
- package/src/prover/smt/solver/seq-subset.ts +165 -0
- package/src/prover/smt/solver/seq-view-witness.ts +353 -0
- package/src/prover/smt/solver/smt-consequences.ts +297 -0
- package/src/prover/smt/solver/smt-kernel.ts +124 -0
- package/src/prover/smt/solver/smt-logics.ts +66 -0
- package/src/prover/smt/solver/smt-setup.ts +589 -0
- package/src/prover/smt/solver/smt2-printer.ts +765 -0
- package/src/prover/smt/solver/smtlib-parser.ts +3535 -360
- package/src/prover/smt/solver/smtlib-script.ts +2136 -0
- package/src/prover/smt/solver/solve-eqs.ts +928 -0
- package/src/prover/smt/solver/solver.ts +128 -23
- package/src/prover/smt/solver/static-features.ts +314 -0
- package/src/prover/smt/solver/sticky-generations.ts +0 -1
- package/src/prover/smt/solver/tactic.ts +2176 -0
- package/src/prover/smt/solver/term-enumeration.ts +205 -0
- package/src/prover/smt/solver/theory-array.ts +1240 -0
- package/src/prover/smt/solver/theory-bv.ts +1210 -0
- package/src/prover/smt/solver/theory-char.ts +355 -0
- package/src/prover/smt/solver/theory-datatype.ts +598 -0
- package/src/prover/smt/solver/theory-finite-set.ts +30 -0
- package/src/prover/smt/solver/theory-fpa.ts +389 -0
- package/src/prover/smt/solver/theory-lra-axioms.ts +53 -2
- package/src/prover/smt/solver/theory-lra-bounds.ts +31 -6
- package/src/prover/smt/solver/theory-lra-final-check.ts +57 -70
- package/src/prover/smt/solver/theory-lra-internalize.ts +96 -27
- package/src/prover/smt/solver/theory-lra-model.ts +20 -35
- package/src/prover/smt/solver/theory-lra-propagate.ts +35 -28
- package/src/prover/smt/solver/theory-lra-state.ts +7 -23
- package/src/prover/smt/solver/theory-lra.ts +189 -2
- package/src/prover/smt/solver/theory-pb.ts +951 -0
- package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
- package/src/prover/smt/solver/theory-recfun.ts +307 -0
- package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
- package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
- package/src/prover/smt/solver/theory-seq-state.ts +852 -0
- package/src/prover/smt/solver/theory-seq.ts +961 -0
- package/src/prover/smt/solver/theory-without-terms.ts +24 -0
- package/src/prover/smt/solver/theory.ts +189 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +495 -0
- package/src/prover/smt/solver/var-subst.ts +36 -14
- package/src/prover/smt/table.ts +3 -2
- package/src/prover/smt/types.ts +146 -0
- package/src/prover/tlapm/cache.ts +57 -26
- package/src/prover/tlapm/tlapm.ts +15 -9
- package/src/prover/tlapm-library.ts +3208 -0
- package/src/prover/verdict.ts +9 -0
- package/src/prover/zenon/check/check.ts +1 -2
- package/src/prover/zenon/check/records.ts +1 -1
- package/src/prover/zenon/check/relations.ts +2 -1
- package/src/prover/zenon/check/rewrites.ts +2 -15
- package/src/prover/zenon/check/sets.ts +40 -58
- package/src/prover/zenon/check/terms.ts +1 -2
- package/src/prover/zenon/decide.ts +10 -7
- package/src/prover/zenon/encode.ts +0 -2
- package/src/prover/zenon/eqrel.ts +2 -2
- package/src/prover/zenon/equality-rules.ts +24 -2
- package/src/prover/zenon/expr.ts +28 -2
- package/src/prover/zenon/index-table.ts +16 -23
- package/src/prover/zenon/isar-case.ts +1 -3
- package/src/prover/zenon/isar.ts +37 -39
- package/src/prover/zenon/llproof.ts +2 -13
- package/src/prover/zenon/mltoll.ts +12 -30
- package/src/prover/zenon/node.ts +20 -5
- package/src/prover/zenon/parse.ts +9 -8
- package/src/prover/zenon/phrase.ts +1 -3
- package/src/prover/zenon/proof.ts +0 -2
- package/src/prover/zenon/propositional-rules.ts +0 -2
- package/src/prover/zenon/rules.ts +2 -3
- package/src/prover/zenon/search.ts +11 -19
- package/src/prover/zenon/tla/functions.ts +2 -4
- package/src/prover/zenon/tla/llproof.ts +9 -13
- package/src/prover/zenon/tla/records.ts +1 -8
- package/src/prover/zenon/tla/rewrites.ts +0 -2
- package/src/prover/zenon/tla/sets.ts +22 -22
- package/src/prover/zenon/tla/terms.ts +0 -2
- package/src/prover/zenon/tla/tla.ts +7 -8
- package/src/resolve.ts +1327 -328
- package/src/runtime.ts +25 -2
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +384 -0
- package/src/sany/generator-def-entries.ts +297 -0
- package/src/sany/generator-definitions.ts +688 -0
- package/src/sany/generator-expressions.ts +1123 -0
- package/src/sany/generator-proofs.ts +668 -0
- package/src/sany/generator.ts +161 -2625
- package/src/sany/levels.ts +0 -2
- package/src/sany/lexer.ts +32 -23
- package/src/sany/linter.ts +0 -2
- package/src/sany/modules.ts +4 -2
- package/src/sany/nodes.ts +3 -4
- package/src/sany/report.ts +3 -6
- package/src/sany/selectors.ts +46 -44
- package/src/sany/xml.ts +25 -58
- package/src/search.ts +513 -165
- package/src/simulate.ts +340 -251
- package/src/spec-description.ts +48 -55
- package/src/standard-definitions.ts +5 -0
- package/src/standard-modules.ts +72 -54
- package/src/state-graph.ts +0 -2
- package/src/subexpressions.ts +564 -138
- package/src/substitution-levels.ts +5 -4
- package/src/successors.ts +56 -28
- package/src/symmetry.ts +4 -3
- package/src/tableau.ts +2 -2
- package/src/tlc/fingerprint.ts +81 -9
- package/src/tlc/jar-data.ts +10 -0
- package/src/tlc/messages.ts +23 -18
- package/src/tlc/order.ts +14 -3
- package/src/tlc/random.ts +6 -5
- package/src/tlc/replay.ts +152 -58
- package/src/tlc/summary.ts +29 -14
- package/src/tlc/tlc-operators.ts +12 -11
- package/src/tlc/tlcext-operators.ts +87 -26
- package/src/tlc/trace-spec.ts +27 -60
- package/src/trace-liveness.ts +529 -0
- package/src/typed-tier.ts +6556 -0
- package/src/typescript/actions.ts +2 -4
- package/src/typescript/collections.ts +34 -20
- package/src/typescript/compile.ts +1 -3
- package/src/typescript/formula.ts +5 -3
- package/src/typescript/model.ts +4 -5
- package/src/typescript/steps.ts +20 -18
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +208 -227
- package/src/prover/isabelle/isar/statement.ts +0 -52
- package/src/prover/smt/solver/z3-license.txt +0 -10
- package/src/prover/tlaps-module.ts +0 -510
- package/src/prover/zenon/LICENSE +0 -32
package/src/check.ts
CHANGED
|
@@ -1,18 +1,14 @@
|
|
|
1
1
|
import type { Expression } from "./ast";
|
|
2
2
|
import { parseConfig, type ModelConfig } from "./config";
|
|
3
3
|
import {
|
|
4
|
-
addCoverageRelation,
|
|
5
|
-
buildCoverage,
|
|
6
4
|
countCoverageVariables,
|
|
7
5
|
createCoverage,
|
|
8
|
-
|
|
6
|
+
createCoverageEnvironment,
|
|
9
7
|
getCoverageReport,
|
|
10
8
|
type CoverageReport,
|
|
11
9
|
} from "./coverage";
|
|
12
|
-
import { createEnvironment } from "./environment";
|
|
13
10
|
import {
|
|
14
11
|
createStackOverflowError,
|
|
15
|
-
getErrorExitCode,
|
|
16
12
|
isStackOverflow,
|
|
17
13
|
TlaEvaluationError,
|
|
18
14
|
TlaIllegalStateError,
|
|
@@ -24,21 +20,34 @@ import {
|
|
|
24
20
|
formatRange,
|
|
25
21
|
} from "./errors";
|
|
26
22
|
import {
|
|
27
|
-
createTracingEnvironment,
|
|
28
23
|
describeRange,
|
|
29
24
|
getDefinition,
|
|
30
|
-
isImpure,
|
|
31
25
|
type CallStack,
|
|
32
|
-
type Environment,
|
|
33
26
|
type FingerprintFailure,
|
|
27
|
+
type State,
|
|
34
28
|
} from "./evaluate";
|
|
29
|
+
import { EXIT_STATUS, setExitCode, withLivenessExitCode } from "./exit-codes";
|
|
35
30
|
import {
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
31
|
+
fingerprintReplayed,
|
|
32
|
+
getFailureExitCode,
|
|
33
|
+
getReplayFailure,
|
|
34
|
+
type FailureOptions,
|
|
35
|
+
} from "./check-failure";
|
|
36
|
+
import {
|
|
37
|
+
createTraceBuilder,
|
|
38
|
+
NEXT_RECOVERY_FAILURE,
|
|
39
|
+
type Behavior,
|
|
40
|
+
type SearchPosition,
|
|
41
|
+
type TracedStep,
|
|
42
|
+
} from "./check-trace";
|
|
43
|
+
import {
|
|
44
|
+
createStateTable,
|
|
45
|
+
findStateIndex,
|
|
46
|
+
getStateHash,
|
|
47
|
+
isSameState,
|
|
48
|
+
markSeenState,
|
|
49
|
+
type StateTable,
|
|
50
|
+
} from "./fingerprints";
|
|
42
51
|
import type { JavaOverride } from "./java-overrides";
|
|
43
52
|
import {
|
|
44
53
|
createLivenessChecker,
|
|
@@ -47,22 +56,27 @@ import {
|
|
|
47
56
|
type LiveSuccessor,
|
|
48
57
|
} from "./liveness-checker";
|
|
49
58
|
import {
|
|
59
|
+
addActionCoverage,
|
|
60
|
+
createCheckEnvironment,
|
|
50
61
|
createMissingOperatorError,
|
|
51
62
|
createSearch,
|
|
52
63
|
getIncompleteSuccessorMessage,
|
|
53
64
|
findAssumptionViolation,
|
|
54
65
|
reportInitialStatesProgress,
|
|
55
66
|
reportStartup,
|
|
67
|
+
STOP_WALK,
|
|
68
|
+
walkCoveredSuccessors,
|
|
56
69
|
withNextStateExitCode,
|
|
70
|
+
type CoveredAction,
|
|
57
71
|
} from "./search";
|
|
58
72
|
import {
|
|
59
73
|
getActionLabel,
|
|
60
74
|
getActionSignature,
|
|
61
|
-
|
|
62
|
-
getNextActions,
|
|
75
|
+
getSpecDescription,
|
|
63
76
|
getSpecificationValue,
|
|
64
77
|
toActionValue,
|
|
65
78
|
type SpecAction,
|
|
79
|
+
type SpecDescription,
|
|
66
80
|
} from "./spec-description";
|
|
67
81
|
import {
|
|
68
82
|
createStateWriter,
|
|
@@ -71,6 +85,7 @@ import {
|
|
|
71
85
|
type StateWriter,
|
|
72
86
|
} from "./state-graph";
|
|
73
87
|
import {
|
|
88
|
+
createIncompleteSuccessorError,
|
|
74
89
|
forEachInitialState,
|
|
75
90
|
forEachSuccessor,
|
|
76
91
|
getInitialStates,
|
|
@@ -79,7 +94,6 @@ import {
|
|
|
79
94
|
type Successor,
|
|
80
95
|
} from "./successors";
|
|
81
96
|
import {
|
|
82
|
-
getCodedMessage,
|
|
83
97
|
getFailureMessage,
|
|
84
98
|
getWrappedException,
|
|
85
99
|
isEvalException,
|
|
@@ -90,31 +104,24 @@ import {
|
|
|
90
104
|
} from "./tlc/messages";
|
|
91
105
|
import { createTautologyError } from "./liveness";
|
|
92
106
|
import { KEY_SEPARATOR } from "./resolve";
|
|
93
|
-
import { setFingerprintPolynomial } from "./tlc/fingerprint";
|
|
94
107
|
import { writeTraceSpec } from "./tlc/trace-spec";
|
|
95
|
-
import {
|
|
96
|
-
import {
|
|
97
|
-
getPrimedRanges,
|
|
98
|
-
replayInitialStates,
|
|
99
|
-
replaySuccessors,
|
|
100
|
-
walkSuccessors,
|
|
101
|
-
} from "./tlc/replay";
|
|
108
|
+
import { replayInitialStates, replaySuccessors, walkSuccessors } from "./tlc/replay";
|
|
102
109
|
import { getFingerprintDistance, OUT_DEGREE_BUCKETS } from "./tlc/summary";
|
|
103
|
-
import {
|
|
110
|
+
import {
|
|
111
|
+
createActionRecord,
|
|
112
|
+
createCounterExample,
|
|
113
|
+
type CounterExampleLoop,
|
|
114
|
+
} from "./tlc/tlcext-operators";
|
|
104
115
|
import type { TlcVersion } from "./tlc/version";
|
|
116
|
+
import { runTypedSearch, type TypedResult } from "./typed-tier";
|
|
105
117
|
import {
|
|
106
|
-
combineHash,
|
|
107
118
|
createCanonicalizer,
|
|
108
119
|
createModelValue,
|
|
109
120
|
formatState,
|
|
110
121
|
getFingerprintError,
|
|
111
|
-
getHeldValues,
|
|
112
122
|
getModelValues,
|
|
113
|
-
getValueHash,
|
|
114
123
|
isSameValue,
|
|
115
124
|
markFingerprinted,
|
|
116
|
-
setStringOrder,
|
|
117
|
-
setValueOptions,
|
|
118
125
|
type Value,
|
|
119
126
|
} from "./values";
|
|
120
127
|
|
|
@@ -146,6 +153,8 @@ export interface CheckOptions {
|
|
|
146
153
|
isTool?: boolean;
|
|
147
154
|
/** TLC's -continue: reports each violation through onProgress and goes on. */
|
|
148
155
|
isContinued?: boolean;
|
|
156
|
+
/** Skips fingerprintDistance, which takes fingerprinting every state again after the search. */
|
|
157
|
+
isFingerprintDistanceSkipped?: boolean;
|
|
149
158
|
moduleOperators?: ModuleOperator[];
|
|
150
159
|
/** TLC's trace exploration spec, and the binary trace TLC records for it unless -noTEBin. */
|
|
151
160
|
traceSpec?: TraceSpecOptions;
|
|
@@ -200,7 +209,7 @@ export type CheckProgress =
|
|
|
200
209
|
branches: number;
|
|
201
210
|
/** Whether TLC checks the complete state graph. */
|
|
202
211
|
isComplete: boolean;
|
|
203
|
-
/** How many states of
|
|
212
|
+
/** How many states the graphs of all branches have together. */
|
|
204
213
|
states: number;
|
|
205
214
|
statistics: SearchStatistics;
|
|
206
215
|
}
|
|
@@ -261,6 +270,11 @@ export interface Postcondition {
|
|
|
261
270
|
counts?: string;
|
|
262
271
|
}
|
|
263
272
|
|
|
273
|
+
export interface TraceFailure extends FailureMessage {
|
|
274
|
+
/** What the spec prints as TLC rebuilds the step it then fails to print. */
|
|
275
|
+
output: OutputLine[];
|
|
276
|
+
}
|
|
277
|
+
|
|
264
278
|
/** An evaluation that failed during the search, with the behavior up to the state TLC was working on. */
|
|
265
279
|
export interface EvaluationFailure {
|
|
266
280
|
code: number;
|
|
@@ -277,19 +291,13 @@ export interface EvaluationFailure {
|
|
|
277
291
|
/** The FingerprintException the replay raises, which TLC reports in place of the call stack. */
|
|
278
292
|
fingerprint?: FingerprintFailure;
|
|
279
293
|
/** How TLC reports failing again as it prints the trace, since it can't fingerprint the state. */
|
|
280
|
-
traceFailure?:
|
|
294
|
+
traceFailure?: TraceFailure;
|
|
281
295
|
/** A POSTCONDITION that is false or fails after the trace, which TLC checks as it prints one. */
|
|
282
296
|
postcondition?: Postcondition;
|
|
283
297
|
/** Whether TLC stops before it prints the statistics, as it does for an illegal initial state. */
|
|
284
298
|
isWithoutStatistics?: boolean;
|
|
285
299
|
}
|
|
286
300
|
|
|
287
|
-
interface ReplayFailure {
|
|
288
|
-
callStack: Expression[];
|
|
289
|
-
fingerprint: FingerprintFailure | undefined;
|
|
290
|
-
replayError?: TlaEvaluationError;
|
|
291
|
-
}
|
|
292
|
-
|
|
293
301
|
export interface InitialStates {
|
|
294
302
|
generated: number;
|
|
295
303
|
distinct: number;
|
|
@@ -309,7 +317,7 @@ export interface CheckResult {
|
|
|
309
317
|
outDegrees: number[] | undefined;
|
|
310
318
|
/** The smallest distance between two fingerprints, when TLC estimates a collision from them. */
|
|
311
319
|
fingerprintDistance: bigint | undefined;
|
|
312
|
-
/** A temporal property TLC finds violated as it adds
|
|
320
|
+
/** A temporal property TLC finds violated as it adds the state it stopped at to the behavior graph, reported after. */
|
|
313
321
|
additionalViolation?: Violation;
|
|
314
322
|
/** Where TLC's worker fails to add the state to the behavior graph after it reports a violation. */
|
|
315
323
|
liveCallStack?: Expression[];
|
|
@@ -319,49 +327,12 @@ export interface CheckResult {
|
|
|
319
327
|
coverage?: CoverageReport;
|
|
320
328
|
}
|
|
321
329
|
|
|
322
|
-
interface CoveredAction extends SpecAction {
|
|
323
|
-
node: number;
|
|
324
|
-
}
|
|
325
|
-
|
|
326
|
-
interface Behavior {
|
|
327
|
-
trace: TraceStep[];
|
|
328
|
-
traceOutput?: OutputLine[];
|
|
329
|
-
}
|
|
330
|
-
|
|
331
|
-
interface TraceOptions {
|
|
332
|
-
loopStart?: number;
|
|
333
|
-
known?: number;
|
|
334
|
-
}
|
|
335
|
-
|
|
336
330
|
interface ReportedViolation extends Omit<Violation, "loopStart"> {
|
|
337
331
|
loopStart?: number;
|
|
338
332
|
}
|
|
339
333
|
|
|
340
|
-
interface
|
|
341
|
-
|
|
342
|
-
level: number;
|
|
343
|
-
}
|
|
344
|
-
|
|
345
|
-
interface SearchPosition {
|
|
346
|
-
index: number;
|
|
347
|
-
isExpanding: boolean;
|
|
348
|
-
candidate: Value[] | undefined;
|
|
349
|
-
candidateLevel: number;
|
|
350
|
-
livenessSource: number;
|
|
351
|
-
rebuilt: RebuiltState | undefined;
|
|
352
|
-
}
|
|
353
|
-
|
|
354
|
-
interface FailureOptions {
|
|
355
|
-
initialState?: Value[];
|
|
356
|
-
isInitial?: boolean;
|
|
357
|
-
outDegrees?: number[];
|
|
358
|
-
callStack?: Expression[];
|
|
359
|
-
fingerprint?: FingerprintFailure;
|
|
360
|
-
replayError?: TlaEvaluationError;
|
|
361
|
-
isNextState?: boolean;
|
|
362
|
-
isCallStackFirst?: boolean;
|
|
363
|
-
traceFailure?: FailureMessage;
|
|
364
|
-
isLiveCallStack?: boolean;
|
|
334
|
+
interface CounterExampleOptions {
|
|
335
|
+
isConsole: boolean;
|
|
365
336
|
}
|
|
366
337
|
|
|
367
338
|
const appendTraceOutput = <Traced extends Behavior>(behavior: Traced, lines: OutputLine[]) => ({
|
|
@@ -369,26 +340,22 @@ const appendTraceOutput = <Traced extends Behavior>(behavior: Traced, lines: Out
|
|
|
369
340
|
traceOutput: [...(behavior.traceOutput ?? []), ...lines],
|
|
370
341
|
});
|
|
371
342
|
|
|
372
|
-
const
|
|
373
|
-
|
|
374
|
-
|
|
375
|
-
|
|
376
|
-
const STOP_WALK = new Error("The walk stopped");
|
|
343
|
+
const toUnexpectedError = (error: TlaEvaluationError) =>
|
|
344
|
+
new TlaEvaluationError(
|
|
345
|
+
`${isEvalException(error) ? UNEXPECTED_EVAL_EXCEPTION : UNEXPECTED_EXCEPTION}${error.message}`,
|
|
346
|
+
);
|
|
377
347
|
|
|
378
|
-
const
|
|
379
|
-
|
|
380
|
-
|
|
381
|
-
|
|
382
|
-
|
|
383
|
-
|
|
384
|
-
|
|
385
|
-
|
|
348
|
+
const getTraceFailure = (error: TlaEvaluationError, output: OutputLine[]): TraceFailure => ({
|
|
349
|
+
...getFailureMessage(
|
|
350
|
+
isEvalException(error)
|
|
351
|
+
? new TlaEvaluationError(`${UNEXPECTED_EVAL_EXCEPTION}${error.message}`)
|
|
352
|
+
: error,
|
|
353
|
+
true,
|
|
354
|
+
),
|
|
355
|
+
output,
|
|
356
|
+
});
|
|
386
357
|
|
|
387
|
-
const
|
|
388
|
-
const inner = error.cause;
|
|
389
|
-
if (inner instanceof TlaEvaluationError) return getReplayExitCode(inner);
|
|
390
|
-
return error instanceof TlaModuleError ? error.exitCode : EXIT_STATUS.specEvaluationFailure;
|
|
391
|
-
};
|
|
358
|
+
const STOP_REPLAY = new Error("The replay stopped");
|
|
392
359
|
|
|
393
360
|
export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
394
361
|
const stateWriter =
|
|
@@ -428,53 +395,24 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
428
395
|
capturedLines = outer;
|
|
429
396
|
}
|
|
430
397
|
};
|
|
431
|
-
const
|
|
432
|
-
|
|
433
|
-
setValueOptions(options);
|
|
434
|
-
setFingerprintPolynomial(options.fingerprintPolynomial ?? 0);
|
|
435
|
-
const specification = createEnvironment(config, {
|
|
436
|
-
source: options.source,
|
|
437
|
-
loadModule: options.loadModule,
|
|
438
|
-
order,
|
|
439
|
-
loadClass: options.loadClass,
|
|
440
|
-
print,
|
|
441
|
-
files: {
|
|
442
|
-
readFile: options.readFile,
|
|
443
|
-
writeFile: options.writeFile,
|
|
444
|
-
makeDirectory: options.makeDirectory,
|
|
445
|
-
},
|
|
446
|
-
seed: options.seed,
|
|
447
|
-
isTool: options.isTool,
|
|
448
|
-
traceFile: options.traceSpec?.traceFile,
|
|
449
|
-
isSanyReported: options.isSanyReported,
|
|
450
|
-
isWarningEnabled: options.isWarningEnabled,
|
|
451
|
-
version: options.version,
|
|
452
|
-
moduleOperators: options.moduleOperators,
|
|
453
|
-
});
|
|
398
|
+
const created = createCheckEnvironment(config, options, print);
|
|
399
|
+
const specification = created.specification;
|
|
454
400
|
reportStartup(specification, config, options.onProgress);
|
|
455
401
|
const coverage =
|
|
456
402
|
options.coverage === undefined
|
|
457
403
|
? undefined
|
|
458
404
|
: createCoverage(specification.environment.variables.length);
|
|
459
|
-
const environment
|
|
460
|
-
?
|
|
461
|
-
...specification.environment,
|
|
462
|
-
evaluators: new WeakMap(),
|
|
463
|
-
entryEvaluators: new WeakMap(),
|
|
464
|
-
definitionEvaluators: new WeakMap(),
|
|
465
|
-
coverage,
|
|
466
|
-
}
|
|
405
|
+
const environment = coverage
|
|
406
|
+
? createCoverageEnvironment(specification.environment, coverage)
|
|
467
407
|
: specification.environment;
|
|
468
408
|
const runtime = environment.runtime;
|
|
469
409
|
const is174 = runtime.version === "1.7.4";
|
|
470
410
|
runtime.pause = options.onPause ?? (() => {});
|
|
411
|
+
let description: SpecDescription | undefined;
|
|
412
|
+
const getDescription = () =>
|
|
413
|
+
(description ??= getSpecDescription(config, environment, specification.instanceActions));
|
|
471
414
|
runtime.getSpecification = () =>
|
|
472
|
-
getSpecificationValue(
|
|
473
|
-
config,
|
|
474
|
-
environment,
|
|
475
|
-
specification.variableLocations,
|
|
476
|
-
specification.instanceActions,
|
|
477
|
-
);
|
|
415
|
+
getSpecificationValue(getDescription(), config, environment, specification.variableLocations);
|
|
478
416
|
let searchDepth = 0;
|
|
479
417
|
let computedInitialStates: InitialStates | undefined;
|
|
480
418
|
const getTraceSpec = (trace: TraceStep[], loopStart: number | undefined) =>
|
|
@@ -493,6 +431,15 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
493
431
|
key.startsWith(`${name}${KEY_SEPARATOR}`),
|
|
494
432
|
),
|
|
495
433
|
});
|
|
434
|
+
const getCoverage = () =>
|
|
435
|
+
coverage?.relations.some((relation) => relation.kind === "next")
|
|
436
|
+
? getCoverageReport(
|
|
437
|
+
coverage,
|
|
438
|
+
environment,
|
|
439
|
+
specification.variableLocations,
|
|
440
|
+
search?.getTlcOrder() ?? [],
|
|
441
|
+
)
|
|
442
|
+
: undefined;
|
|
496
443
|
const createResult = (
|
|
497
444
|
status: CheckStatus,
|
|
498
445
|
violation?: ReportedViolation,
|
|
@@ -513,14 +460,7 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
513
460
|
initialStates: computedInitialStates,
|
|
514
461
|
outDegrees: undefined,
|
|
515
462
|
fingerprintDistance: undefined,
|
|
516
|
-
coverage:
|
|
517
|
-
? getCoverageReport(
|
|
518
|
-
coverage,
|
|
519
|
-
environment,
|
|
520
|
-
specification.variableLocations,
|
|
521
|
-
search?.getTlcOrder() ?? [],
|
|
522
|
-
)
|
|
523
|
-
: undefined,
|
|
463
|
+
coverage: getCoverage(),
|
|
524
464
|
...(traceSpec !== undefined && { traceSpec }),
|
|
525
465
|
};
|
|
526
466
|
};
|
|
@@ -539,23 +479,30 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
539
479
|
const createSuccess = (): CheckResult => ({
|
|
540
480
|
...createResult("success"),
|
|
541
481
|
outDegrees: [...outDegrees],
|
|
542
|
-
fingerprintDistance:
|
|
543
|
-
|
|
544
|
-
runtime.generatedStates,
|
|
545
|
-
|
|
546
|
-
|
|
547
|
-
|
|
548
|
-
|
|
549
|
-
|
|
482
|
+
fingerprintDistance: options.isFingerprintDistanceSkipped
|
|
483
|
+
? undefined
|
|
484
|
+
: getFingerprintDistance(runtime.distinctStates, runtime.generatedStates, (visit) =>
|
|
485
|
+
visit(
|
|
486
|
+
search
|
|
487
|
+
? search.getStoredFingerprints(
|
|
488
|
+
exploredStates.length === 0 ? states : states.concat(exploredStates),
|
|
489
|
+
exploredStates.length === 0
|
|
490
|
+
? fingerprintStates
|
|
491
|
+
: fingerprintStates.concat(exploredFingerprintStates),
|
|
492
|
+
)
|
|
493
|
+
: BigInt64Array.from(states, runtime.getFingerprint),
|
|
494
|
+
),
|
|
495
|
+
),
|
|
550
496
|
});
|
|
551
497
|
|
|
552
498
|
const search = createSearch(
|
|
553
499
|
config,
|
|
554
500
|
environment,
|
|
555
501
|
specification.variableLocations,
|
|
556
|
-
() => order.getDeclarationOrder("variable"),
|
|
502
|
+
() => created.order.getDeclarationOrder("variable"),
|
|
557
503
|
options.onProgress,
|
|
558
504
|
specification.moduleOperators,
|
|
505
|
+
specification.runtimeInvariants,
|
|
559
506
|
);
|
|
560
507
|
const findViolatedAssumption = () =>
|
|
561
508
|
findAssumptionViolation(specification.assumptions, environment);
|
|
@@ -575,24 +522,26 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
575
522
|
config.postconditions.length > 0 ||
|
|
576
523
|
config.possible.length > 0 ||
|
|
577
524
|
specification.moduleOperators.some((operator) => operator.kind === "postcondition");
|
|
578
|
-
const
|
|
579
|
-
|
|
580
|
-
|
|
581
|
-
|
|
582
|
-
const getStepState = (step: TraceStep) => traceSteps.get(step)?.state ?? step.state;
|
|
525
|
+
const tracedSteps = new WeakMap<TraceStep, TracedStep>();
|
|
526
|
+
const getStepState = (step: TraceStep) => tracedSteps.get(step)?.state ?? step.state;
|
|
527
|
+
// TLC's Worker#doPostCondition and LiveCheck bind CounterExample to the alias of each state, while its initial states and lassos keep the states.
|
|
528
|
+
const getStepAlias = (step: TraceStep) => tracedSteps.get(step)?.alias ?? step.state;
|
|
583
529
|
const getStepAction = (step: TraceStep) => {
|
|
584
|
-
const action =
|
|
530
|
+
const action = tracedSteps.get(step)?.action;
|
|
585
531
|
return action ? toActionValue(action) : createActionRecord(step.action);
|
|
586
532
|
};
|
|
587
533
|
const checkTracePostconditions = (
|
|
588
534
|
trace: TraceStep[],
|
|
589
|
-
loop:
|
|
535
|
+
loop: CounterExampleLoop | undefined,
|
|
536
|
+
getState: (step: TraceStep) => Record<string, Value>,
|
|
537
|
+
isConsole = true,
|
|
590
538
|
) => {
|
|
591
539
|
if (hasPostconditions) {
|
|
592
540
|
runtime.counterExample = createCounterExample(
|
|
593
|
-
trace.map(
|
|
541
|
+
trace.map(getState),
|
|
594
542
|
trace.slice(1).map(getStepAction),
|
|
595
543
|
loop,
|
|
544
|
+
isConsole,
|
|
596
545
|
);
|
|
597
546
|
}
|
|
598
547
|
const unwitnessed = search.findUnwitnessedPossible();
|
|
@@ -604,12 +553,14 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
604
553
|
const reportViolation = (
|
|
605
554
|
status: CheckStatus,
|
|
606
555
|
violation: ReportedViolation,
|
|
556
|
+
getState = getStepAlias,
|
|
607
557
|
getLoopAction?: () => Value,
|
|
608
558
|
) => {
|
|
609
559
|
const start = violation.loopStart;
|
|
610
560
|
const checked = checkTracePostconditions(
|
|
611
561
|
violation.trace,
|
|
612
562
|
start === undefined || !getLoopAction ? undefined : { start, action: getLoopAction() },
|
|
563
|
+
getState,
|
|
613
564
|
);
|
|
614
565
|
return createResult(status, {
|
|
615
566
|
...violation,
|
|
@@ -633,68 +584,47 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
633
584
|
};
|
|
634
585
|
const spec = search.spec;
|
|
635
586
|
const getFingerprintState = search.getFingerprintState;
|
|
636
|
-
let specNextActions: SpecAction[] | undefined;
|
|
637
|
-
const getSpecNextActions = () =>
|
|
638
|
-
(specNextActions ??= getNextActions(config, environment, specification.instanceActions));
|
|
639
587
|
// Tool's constructor splits the next-state relation into actions before TLC checks anything.
|
|
640
|
-
|
|
641
|
-
|
|
642
|
-
|
|
643
|
-
|
|
644
|
-
|
|
645
|
-
|
|
646
|
-
|
|
647
|
-
const addCoverageRelations = (kind: "init" | "next", actions: SpecAction[]) =>
|
|
648
|
-
actions.map((action): CoveredAction => ({
|
|
649
|
-
...action,
|
|
650
|
-
node: coverage
|
|
651
|
-
? addCoverageRelation(
|
|
652
|
-
coverage,
|
|
653
|
-
kind,
|
|
654
|
-
getCoverageLabel(action.name, action.expression, environment),
|
|
655
|
-
action.expression,
|
|
656
|
-
action.scope,
|
|
657
|
-
)
|
|
658
|
-
: -1,
|
|
659
|
-
}));
|
|
660
|
-
const coverageInits = addCoverageRelations(
|
|
661
|
-
"init",
|
|
662
|
-
coverage ? getInitActions(config, environment, specification.instanceActions) : [],
|
|
663
|
-
);
|
|
664
|
-
const coverageActions = addCoverageRelations("next", coverage ? getSpecNextActions() : []);
|
|
665
|
-
if (coverage) buildCoverage(coverage, environment, getPrimedRanges(coverageActions, environment));
|
|
666
|
-
const walkCoveredSuccessors = (
|
|
667
|
-
action: CoveredAction,
|
|
668
|
-
state: Value[],
|
|
669
|
-
onState: (successor: Value[]) => void,
|
|
670
|
-
) =>
|
|
588
|
+
const nextActions = getDescription().actions;
|
|
589
|
+
const covered = coverage && addActionCoverage(coverage, environment, getDescription());
|
|
590
|
+
const coverageInits = covered?.inits ?? [];
|
|
591
|
+
const coverageActions = covered?.actions ?? [];
|
|
592
|
+
const hasCoveredIncompleteSuccessor = (action: CoveredAction, state: Value[]) => {
|
|
593
|
+
let complete = 0;
|
|
594
|
+
let incomplete = 0;
|
|
671
595
|
walkSuccessors(
|
|
672
596
|
action,
|
|
673
597
|
action.node,
|
|
674
598
|
state,
|
|
675
599
|
environment,
|
|
676
|
-
(
|
|
677
|
-
|
|
678
|
-
|
|
679
|
-
|
|
680
|
-
(partial) => {
|
|
681
|
-
const missing = environment.variables.filter(
|
|
682
|
-
(_variable, index) => partial[index] === undefined,
|
|
683
|
-
);
|
|
684
|
-
throw new TlaIncompleteSuccessorError(
|
|
685
|
-
`Successor state is not completely specified by action ${action.name}. The following variables are not assigned: ${missing.join(", ")}`,
|
|
686
|
-
partial,
|
|
687
|
-
action.name,
|
|
688
|
-
missing,
|
|
689
|
-
);
|
|
600
|
+
() => complete++,
|
|
601
|
+
() => {
|
|
602
|
+
incomplete++;
|
|
603
|
+
return true;
|
|
690
604
|
},
|
|
691
605
|
);
|
|
692
|
-
|
|
693
|
-
|
|
694
|
-
|
|
695
|
-
|
|
606
|
+
if (coverage) coverage.primary[action.node] += complete + incomplete;
|
|
607
|
+
return incomplete > 0;
|
|
608
|
+
};
|
|
609
|
+
// TLC generates the successors of each action again, which its coverage counts.
|
|
610
|
+
const findSuccessorAction = (state: Value[], isMatch: (successor: Successor) => boolean) =>
|
|
611
|
+
coverage
|
|
612
|
+
? coverageActions.find((item) => {
|
|
613
|
+
const successors: Successor[] = [];
|
|
614
|
+
walkCoveredSuccessors(coverage, item, state, environment, (successor) =>
|
|
615
|
+
successors.push({ state: successor, action: item.name }),
|
|
616
|
+
);
|
|
617
|
+
return successors.some(isMatch);
|
|
618
|
+
})
|
|
619
|
+
: nextActions.find((item) =>
|
|
620
|
+
getSuccessors(item.expression, state, environment, item.scope).some(isMatch),
|
|
621
|
+
);
|
|
622
|
+
runtime.getSuccessorAction = (state, next) =>
|
|
623
|
+
findSuccessorAction(state, (successor) =>
|
|
624
|
+
successor.state.every((value, index) => isSameValue(value, next[index])),
|
|
696
625
|
);
|
|
697
|
-
|
|
626
|
+
const rejectIncompleteInitialState = (partial: (Value | undefined)[]) => {
|
|
627
|
+
throw setExitCode(new TlaIllegalStateError([...partial]), EXIT_STATUS.error);
|
|
698
628
|
};
|
|
699
629
|
const getCoveredInitialStates = () => {
|
|
700
630
|
const initialStates: Value[][] = [];
|
|
@@ -702,58 +632,19 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
702
632
|
coverageInits,
|
|
703
633
|
environment,
|
|
704
634
|
(state) => initialStates.push(state),
|
|
705
|
-
|
|
706
|
-
throw setExitCode(new TlaIllegalStateError([...partial]), EXIT_STATUS.error);
|
|
707
|
-
},
|
|
635
|
+
rejectIncompleteInitialState,
|
|
708
636
|
);
|
|
709
637
|
return initialStates;
|
|
710
638
|
};
|
|
711
|
-
const getReplayFailure = (replay: (tracing: Environment) => void): ReplayFailure | undefined => {
|
|
712
|
-
const tracing = createTracingEnvironment(environment);
|
|
713
|
-
const callStack = tracing.callStack;
|
|
714
|
-
try {
|
|
715
|
-
replay(tracing);
|
|
716
|
-
return undefined;
|
|
717
|
-
} catch (error) {
|
|
718
|
-
if (isStackOverflow(error)) return { callStack: [], fingerprint: undefined };
|
|
719
|
-
if (!(error instanceof TlaEvaluationError) || !callStack) return undefined;
|
|
720
|
-
return {
|
|
721
|
-
callStack: callStack.expressions,
|
|
722
|
-
fingerprint: callStack.fingerprint,
|
|
723
|
-
replayError: error,
|
|
724
|
-
};
|
|
725
|
-
}
|
|
726
|
-
};
|
|
727
|
-
const findFailedSources = (value: Value, sources: CallStack["sources"]): Expression[] => {
|
|
728
|
-
if (typeof value !== "object") return [];
|
|
729
|
-
const source = sources.get(value);
|
|
730
|
-
const failed = getHeldValues(value).find((held) => getFingerprintError(held) !== undefined);
|
|
731
|
-
return [
|
|
732
|
-
...(source ? [source] : []),
|
|
733
|
-
...(failed === undefined ? [] : findFailedSources(failed, sources)),
|
|
734
|
-
];
|
|
735
|
-
};
|
|
736
|
-
const fingerprintReplayed = (state: Value[], callStack: CallStack | undefined) => {
|
|
737
|
-
for (const value of getFingerprintState(state)) {
|
|
738
|
-
const error = getFingerprintError(value);
|
|
739
|
-
if (!error) continue;
|
|
740
|
-
const sources = callStack ? findFailedSources(value, callStack.sources) : [];
|
|
741
|
-
if (callStack && sources.length > 0) {
|
|
742
|
-
callStack.expressions.length = 0;
|
|
743
|
-
callStack.isFrozen = true;
|
|
744
|
-
callStack.fingerprint = { sources, reason: error.message };
|
|
745
|
-
}
|
|
746
|
-
throw error;
|
|
747
|
-
}
|
|
748
|
-
state.forEach(markFingerprinted);
|
|
749
|
-
};
|
|
750
639
|
const createReplayedStates = () => {
|
|
751
640
|
const replayed = unstoredFingerprint ? [unstoredFingerprint] : [];
|
|
752
641
|
return (state: Value[], callStack: CallStack | undefined) => {
|
|
753
|
-
fingerprintReplayed(state, callStack);
|
|
642
|
+
fingerprintReplayed(state, getFingerprintState(state), callStack);
|
|
754
643
|
const fingerprintState = getFingerprintState(state);
|
|
644
|
+
const hash = getStateHash(fingerprintState);
|
|
755
645
|
const isSeen =
|
|
756
|
-
findStateIndex(
|
|
646
|
+
findStateIndex(seenStates, hash, fingerprintState) !== -1 ||
|
|
647
|
+
isExplored(hash, fingerprintState) ||
|
|
757
648
|
replayed.some((seen) => isSameState(seen, fingerprintState));
|
|
758
649
|
if (isSeen) return false;
|
|
759
650
|
replayed.push(fingerprintState);
|
|
@@ -765,48 +656,45 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
765
656
|
let replayedCount = 0;
|
|
766
657
|
const deferred: unknown[] = [];
|
|
767
658
|
const addReplayed = createReplayedStates();
|
|
768
|
-
return getReplayFailure((tracing) => {
|
|
769
|
-
replayInitialStates(
|
|
770
|
-
|
|
771
|
-
|
|
772
|
-
|
|
773
|
-
|
|
774
|
-
|
|
775
|
-
|
|
776
|
-
|
|
777
|
-
|
|
778
|
-
|
|
779
|
-
|
|
780
|
-
|
|
781
|
-
|
|
782
|
-
|
|
783
|
-
|
|
784
|
-
|
|
785
|
-
|
|
786
|
-
|
|
787
|
-
|
|
788
|
-
...violation,
|
|
789
|
-
state: traced,
|
|
790
|
-
});
|
|
659
|
+
return getReplayFailure(environment, (tracing) => {
|
|
660
|
+
replayInitialStates(coverage ? coverageInits : getDescription().inits, tracing, (state) => {
|
|
661
|
+
reportInitialStatesProgress(replayedCount, (progress) => capturedLines?.push(progress));
|
|
662
|
+
replayedCount++;
|
|
663
|
+
runtime.generatedStates = replayedCount;
|
|
664
|
+
if (deferred.length > 0) return;
|
|
665
|
+
try {
|
|
666
|
+
const addFingerprint = () => {
|
|
667
|
+
if (!addReplayed(state, tracing.callStack)) return;
|
|
668
|
+
runtime.queueSize++;
|
|
669
|
+
liveness?.addInitialState(states.length, state, tracing);
|
|
670
|
+
};
|
|
671
|
+
search.checkReplayedInitialState(state, tracing, addFingerprint, (violation) => {
|
|
672
|
+
const traced = traces.toTrace([{ action: undefined, state }], []).trace[0].state;
|
|
673
|
+
capturedLines?.push({
|
|
674
|
+
kind: "initial-state-violation",
|
|
675
|
+
...violation,
|
|
676
|
+
state: traced,
|
|
677
|
+
});
|
|
678
|
+
if (!options.isContinued || violation.status !== "invariant-violation") {
|
|
791
679
|
throw STOP_REPLAY;
|
|
792
680
|
}
|
|
793
|
-
}
|
|
794
|
-
|
|
795
|
-
|
|
796
|
-
|
|
797
|
-
|
|
798
|
-
|
|
799
|
-
}
|
|
800
|
-
);
|
|
681
|
+
});
|
|
682
|
+
} catch (error) {
|
|
683
|
+
const isFingerprintFailure =
|
|
684
|
+
error instanceof TlaEvaluationError && tracing.callStack?.fingerprint !== undefined;
|
|
685
|
+
if (!isFingerprintFailure && !isStackOverflow(error)) throw error;
|
|
686
|
+
deferred.push(error);
|
|
687
|
+
}
|
|
688
|
+
});
|
|
801
689
|
if (deferred.length > 0) throw deferred[0];
|
|
802
690
|
});
|
|
803
691
|
};
|
|
804
692
|
const replayNext = (index: number) =>
|
|
805
|
-
getReplayFailure((tracing) => {
|
|
693
|
+
getReplayFailure(environment, (tracing) => {
|
|
806
694
|
const state = states[index];
|
|
807
695
|
const source = stateWriter && getGraphState(state, depths[index]);
|
|
808
696
|
const addReplayed = createReplayedStates();
|
|
809
|
-
replaySuccessors(
|
|
697
|
+
replaySuccessors(coverage ? coverageActions : nextActions, state, tracing, (next, action) => {
|
|
810
698
|
const addFingerprint = () => {
|
|
811
699
|
const isUnseen = addReplayed(next, tracing.callStack);
|
|
812
700
|
if (source) {
|
|
@@ -824,7 +712,6 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
824
712
|
}
|
|
825
713
|
});
|
|
826
714
|
});
|
|
827
|
-
const isReducing = config.view !== undefined || config.symmetry !== undefined;
|
|
828
715
|
const tlcFingerprints: number[] = [];
|
|
829
716
|
if (search.properties.liveness.length > 0) {
|
|
830
717
|
options.onProgress?.({
|
|
@@ -833,6 +720,15 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
833
720
|
isConstrained: search.isConstrained,
|
|
834
721
|
});
|
|
835
722
|
}
|
|
723
|
+
let liveState: Value[] = [];
|
|
724
|
+
const addIncomplete = (successor: State, action: string | undefined) => {
|
|
725
|
+
if (
|
|
726
|
+
search.satisfiesConstraints(successor, liveState) &&
|
|
727
|
+
search.satisfiesActionConstraints(liveState, successor)
|
|
728
|
+
) {
|
|
729
|
+
throw createIncompleteSuccessorError(successor, action, environment);
|
|
730
|
+
}
|
|
731
|
+
};
|
|
836
732
|
const liveness = withLivenessExitCode(() =>
|
|
837
733
|
withUnexpectedException(() =>
|
|
838
734
|
createLivenessChecker(search.properties.liveness, spec.temporals, environment, {
|
|
@@ -840,33 +736,67 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
840
736
|
(tlcFingerprints[successor.index] ??= Number(
|
|
841
737
|
BigInt.asIntN(32, runtime.getFingerprint(successor.state)),
|
|
842
738
|
)),
|
|
843
|
-
|
|
844
|
-
|
|
845
|
-
|
|
846
|
-
const
|
|
847
|
-
|
|
848
|
-
|
|
849
|
-
|
|
850
|
-
|
|
851
|
-
|
|
852
|
-
|
|
853
|
-
|
|
854
|
-
|
|
855
|
-
|
|
856
|
-
|
|
857
|
-
|
|
858
|
-
|
|
859
|
-
|
|
860
|
-
|
|
861
|
-
|
|
862
|
-
|
|
863
|
-
|
|
864
|
-
|
|
865
|
-
|
|
866
|
-
|
|
867
|
-
|
|
739
|
+
forEachActionSuccessors: (source, state, onSuccessors, replay) => {
|
|
740
|
+
liveState = state;
|
|
741
|
+
let successors: LiveSuccessor[] = [];
|
|
742
|
+
const addSuccessor = (successor: Value[]) => {
|
|
743
|
+
canonicalizeState(successor);
|
|
744
|
+
const isInModel =
|
|
745
|
+
search.satisfiesConstraints(successor, state) &&
|
|
746
|
+
search.satisfiesActionConstraints(state, successor);
|
|
747
|
+
if (!isInModel) return;
|
|
748
|
+
const fingerprintState = getFingerprintState(successor);
|
|
749
|
+
const hash = getStateHash(fingerprintState);
|
|
750
|
+
const index = findStateIndex(seenStates, hash, fingerprintState);
|
|
751
|
+
successors.push({
|
|
752
|
+
index: index === -1 ? getPendingIndex(hash, fingerprintState) : index,
|
|
753
|
+
state: successor,
|
|
754
|
+
});
|
|
755
|
+
};
|
|
756
|
+
const visitSuccessor = (successor: Successor) => {
|
|
757
|
+
addSuccessor(successor.state);
|
|
758
|
+
return false;
|
|
759
|
+
};
|
|
760
|
+
const actionCount = coverage ? coverageActions.length : nextActions.length;
|
|
761
|
+
for (let position = 0; position < actionCount; position++) {
|
|
762
|
+
successors = [];
|
|
763
|
+
const livenessSource = current.livenessSource;
|
|
764
|
+
current.livenessSource = source;
|
|
765
|
+
try {
|
|
766
|
+
if (coverage) {
|
|
767
|
+
// TLC's coverage counts the successors of each action the graph generates again.
|
|
768
|
+
walkCoveredSuccessors(
|
|
769
|
+
coverage,
|
|
770
|
+
coverageActions[position],
|
|
771
|
+
state,
|
|
772
|
+
replay ?? environment,
|
|
773
|
+
addSuccessor,
|
|
774
|
+
addIncomplete,
|
|
775
|
+
);
|
|
776
|
+
} else if (replay) {
|
|
777
|
+
const action = nextActions[position];
|
|
778
|
+
walkSuccessors(action, -1, state, replay, addSuccessor, (partial) => {
|
|
779
|
+
addIncomplete(partial, action.name);
|
|
780
|
+
return true;
|
|
781
|
+
});
|
|
782
|
+
} else {
|
|
783
|
+
const action = nextActions[position];
|
|
784
|
+
forEachSuccessor(
|
|
785
|
+
action.expression,
|
|
786
|
+
state,
|
|
787
|
+
environment,
|
|
788
|
+
visitSuccessor,
|
|
789
|
+
action.scope,
|
|
790
|
+
undefined,
|
|
791
|
+
undefined,
|
|
792
|
+
addIncomplete,
|
|
793
|
+
);
|
|
794
|
+
}
|
|
795
|
+
} finally {
|
|
796
|
+
current.livenessSource = livenessSource;
|
|
797
|
+
}
|
|
798
|
+
onSuccessors(successors);
|
|
868
799
|
}
|
|
869
|
-
return successors;
|
|
870
800
|
},
|
|
871
801
|
}),
|
|
872
802
|
),
|
|
@@ -880,202 +810,32 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
880
810
|
const parents: number[] = [];
|
|
881
811
|
const actions: (string | undefined)[] = [];
|
|
882
812
|
const depths: number[] = [];
|
|
883
|
-
|
|
884
|
-
const
|
|
885
|
-
const
|
|
886
|
-
|
|
887
|
-
const
|
|
888
|
-
|
|
889
|
-
|
|
890
|
-
|
|
891
|
-
|
|
892
|
-
|
|
893
|
-
|
|
894
|
-
const
|
|
895
|
-
|
|
896
|
-
|
|
897
|
-
|
|
898
|
-
try {
|
|
899
|
-
return evaluateAlias(
|
|
900
|
-
alias,
|
|
901
|
-
steps[position].state,
|
|
902
|
-
(steps[position + 1] ?? steps[loopStart ?? position]).state,
|
|
903
|
-
);
|
|
904
|
-
} finally {
|
|
905
|
-
runtime.getLevel = searchLevel;
|
|
906
|
-
runtime.getBehavior = searchBehavior;
|
|
907
|
-
}
|
|
908
|
-
};
|
|
909
|
-
const evaluateAlias = (alias: string, state: Value[], next: Value[] | undefined) =>
|
|
910
|
-
search.evaluateAlias(alias, state, next, options.isTool ?? false);
|
|
911
|
-
const findStepAction = (index: number, previous: Value[], state: Value[], isHeld: boolean) => {
|
|
912
|
-
const actions = getSpecNextActions();
|
|
913
|
-
const expanding = { ...current };
|
|
914
|
-
Object.assign(current, {
|
|
915
|
-
index,
|
|
916
|
-
isExpanding: true,
|
|
917
|
-
candidate: undefined,
|
|
918
|
-
rebuilt: { state: previous, level: depths[index] },
|
|
919
|
-
});
|
|
920
|
-
const getKey = isHeld ? (values: Value[]) => values : getFingerprintState;
|
|
921
|
-
const key = getKey(state);
|
|
922
|
-
try {
|
|
923
|
-
return coverage
|
|
924
|
-
? coverageActions.find((item) =>
|
|
925
|
-
getCoveredSuccessors(item, previous).some((successor) =>
|
|
926
|
-
isSameState(getKey(successor.state), key),
|
|
927
|
-
),
|
|
928
|
-
)
|
|
929
|
-
: actions.find((item) =>
|
|
930
|
-
getSuccessors(item.expression, previous, environment, item.scope).some((successor) =>
|
|
931
|
-
isSameState(getKey(successor.state), key),
|
|
932
|
-
),
|
|
933
|
-
);
|
|
934
|
-
} finally {
|
|
935
|
-
Object.assign(current, expanding);
|
|
813
|
+
const seenStates = createStateTable(fingerprintStates);
|
|
814
|
+
const exploredStates: Value[][] = [];
|
|
815
|
+
const exploredFingerprintStates: Value[][] = [];
|
|
816
|
+
let exploredTable: StateTable | undefined;
|
|
817
|
+
const isExplored = (hash: number, fingerprintState: Value[]) =>
|
|
818
|
+
exploredTable !== undefined && findStateIndex(exploredTable, hash, fingerprintState) !== -1;
|
|
819
|
+
const pendingFingerprintStates: Value[][] = [];
|
|
820
|
+
let pendingStates: StateTable | undefined;
|
|
821
|
+
const getPendingIndex = (hash: number, fingerprintState: Value[]) => {
|
|
822
|
+
pendingStates ??= createStateTable(pendingFingerprintStates);
|
|
823
|
+
const found = findStateIndex(pendingStates, hash, fingerprintState);
|
|
824
|
+
const position = found === -1 ? pendingFingerprintStates.length : found;
|
|
825
|
+
if (found === -1) {
|
|
826
|
+
markSeenState(pendingStates, hash, position);
|
|
827
|
+
pendingFingerprintStates.push(fingerprintState);
|
|
936
828
|
}
|
|
829
|
+
return -2 - position;
|
|
937
830
|
};
|
|
938
|
-
|
|
939
|
-
|
|
940
|
-
|
|
941
|
-
|
|
942
|
-
)
|
|
943
|
-
|
|
944
|
-
|
|
945
|
-
|
|
946
|
-
const stepActions = steps.map((step, position) =>
|
|
947
|
-
position === 0 || step.action === "Stuttering"
|
|
948
|
-
? { result: undefined, lines: [] }
|
|
949
|
-
: captureOutput(() =>
|
|
950
|
-
findStepAction(
|
|
951
|
-
path[position - 1],
|
|
952
|
-
steps[position - 1].state,
|
|
953
|
-
step.state,
|
|
954
|
-
known === 2 && position === steps.length - 1,
|
|
955
|
-
),
|
|
956
|
-
),
|
|
957
|
-
);
|
|
958
|
-
const outputs = stepActions.map((step) => step.lines);
|
|
959
|
-
const loopStart = traceOptions.loopStart;
|
|
960
|
-
const rebuilt = is174 && loopStart !== undefined ? loopStart + 1 : steps.length - known;
|
|
961
|
-
if (coverage && steps.length > 1) {
|
|
962
|
-
const isRebuiltAgain = known > 0 && !is174;
|
|
963
|
-
if (rebuilt > 0 && isRebuiltAgain) captureOutput(getSpecInitialStates);
|
|
964
|
-
if (isRebuiltAgain) {
|
|
965
|
-
steps.slice(1).forEach((step, position) => {
|
|
966
|
-
if (step.action === "Stuttering") return;
|
|
967
|
-
captureOutput(() =>
|
|
968
|
-
findStepAction(
|
|
969
|
-
path[position],
|
|
970
|
-
steps[position].state,
|
|
971
|
-
step.state,
|
|
972
|
-
known === 2 && position === steps.length - 2,
|
|
973
|
-
),
|
|
974
|
-
);
|
|
975
|
-
});
|
|
976
|
-
}
|
|
977
|
-
}
|
|
978
|
-
const prefixOutput = rebuilt > 0 ? [initialOutput, ...outputs.slice(1, rebuilt)].flat() : [];
|
|
979
|
-
return {
|
|
980
|
-
trace: steps.map((step, position) => {
|
|
981
|
-
const action = stepActions[position].result;
|
|
982
|
-
const traceStep: TraceStep = {
|
|
983
|
-
action: step.action,
|
|
984
|
-
label: action && getActionLabel(action, options.version),
|
|
985
|
-
state:
|
|
986
|
-
alias === undefined
|
|
987
|
-
? toRecord(step.state)
|
|
988
|
-
: getAliasState(alias, steps, position, loopStart),
|
|
989
|
-
output: position === 0 ? prefixOutput : position < rebuilt ? [] : outputs[position],
|
|
990
|
-
};
|
|
991
|
-
if (alias !== undefined || action) {
|
|
992
|
-
traceSteps.set(traceStep, { state: toRecord(step.state), action });
|
|
993
|
-
}
|
|
994
|
-
return traceStep;
|
|
995
|
-
}),
|
|
996
|
-
traceOutput: known > 0 && !is174 ? [initialOutput, ...outputs].flat() : [],
|
|
997
|
-
};
|
|
998
|
-
};
|
|
999
|
-
const getSpecInitialStates = () => {
|
|
1000
|
-
if (coverage) return getCoveredInitialStates();
|
|
1001
|
-
return spec.init === undefined ? [] : getInitialStates(spec.init, environment, spec.scope);
|
|
1002
|
-
};
|
|
1003
|
-
const findTraceSuccessor = (state: Value[], isMatch: (successor: Successor) => boolean) =>
|
|
1004
|
-
captureOutput(() => {
|
|
1005
|
-
for (const action of getSpecNextActions()) {
|
|
1006
|
-
const successor = getSuccessors(action.expression, state, environment, action.scope).find(
|
|
1007
|
-
isMatch,
|
|
1008
|
-
);
|
|
1009
|
-
if (successor) return { ...successor, action: successor.action ?? action.name };
|
|
1010
|
-
}
|
|
1011
|
-
return undefined;
|
|
1012
|
-
}).result;
|
|
1013
|
-
const hasFingerprint = (state: Value[], index: number) =>
|
|
1014
|
-
isSameState(getFingerprintState(state), fingerprintStates[index]);
|
|
1015
|
-
const findSuccessorWithFingerprint = (state: Value[], index: number) =>
|
|
1016
|
-
findTraceSuccessor(state, (successor) => hasFingerprint(successor.state, index));
|
|
1017
|
-
const getPathStates = (path: number[], nextFailure: string) => {
|
|
1018
|
-
const initial = captureOutput(() =>
|
|
1019
|
-
isReducing || isImpure(environment)
|
|
1020
|
-
? getSpecInitialStates().find((state) => hasFingerprint(state, path[0]))
|
|
1021
|
-
: states[path[0]],
|
|
1022
|
-
).result;
|
|
1023
|
-
if (!initial) throw new TlaEvaluationError(INITIAL_RECOVERY_FAILURE);
|
|
1024
|
-
const steps: Successor[] = [{ state: initial, action: undefined }];
|
|
1025
|
-
for (let position = 1; position < path.length; position++) {
|
|
1026
|
-
const previous = steps[position - 1].state;
|
|
1027
|
-
if (path[position - 1] === path[position]) {
|
|
1028
|
-
steps.push({ state: previous, action: "Stuttering" });
|
|
1029
|
-
continue;
|
|
1030
|
-
}
|
|
1031
|
-
const rebuilt = current.rebuilt;
|
|
1032
|
-
current.rebuilt = { state: previous, level: depths[path[position - 1]] };
|
|
1033
|
-
const successor = findSuccessorWithFingerprint(previous, path[position]);
|
|
1034
|
-
current.rebuilt = rebuilt;
|
|
1035
|
-
if (!successor) throw new TlaEvaluationError(nextFailure);
|
|
1036
|
-
steps.push(successor);
|
|
1037
|
-
}
|
|
1038
|
-
return steps;
|
|
1039
|
-
};
|
|
1040
|
-
const getTrace = (index: number, lastSuccessor?: Successor) => {
|
|
1041
|
-
const path: number[] = [];
|
|
1042
|
-
for (let position = index; position !== -1; position = parents[position]) {
|
|
1043
|
-
path.unshift(position);
|
|
1044
|
-
}
|
|
1045
|
-
const steps =
|
|
1046
|
-
isReducing && path.length > 1
|
|
1047
|
-
? getPathStates(path, INITIAL_RECOVERY_FAILURE)
|
|
1048
|
-
: path.map((position) => ({ state: states[position], action: actions[position] }));
|
|
1049
|
-
if (!lastSuccessor) return toTrace(steps, path);
|
|
1050
|
-
const action = isReducing
|
|
1051
|
-
? findTraceSuccessor(states[index], (successor) =>
|
|
1052
|
-
isSameState(successor.state, lastSuccessor.state),
|
|
1053
|
-
)?.action
|
|
1054
|
-
: lastSuccessor.action;
|
|
1055
|
-
return toTrace([...steps, { state: lastSuccessor.state, action }], path, { known: 2 });
|
|
1056
|
-
};
|
|
1057
|
-
// Deviation from TLC: TLCTrace#printTrace prints a lone initial state without the alias.
|
|
1058
|
-
const getStateTrace = (index: number): Behavior =>
|
|
1059
|
-
parents[index] === -1
|
|
1060
|
-
? {
|
|
1061
|
-
trace: [
|
|
1062
|
-
{
|
|
1063
|
-
action: undefined,
|
|
1064
|
-
label: undefined,
|
|
1065
|
-
state:
|
|
1066
|
-
config.alias === undefined
|
|
1067
|
-
? toRecord(states[index])
|
|
1068
|
-
: getAliasState(
|
|
1069
|
-
config.alias,
|
|
1070
|
-
[{ state: states[index], action: undefined }],
|
|
1071
|
-
0,
|
|
1072
|
-
undefined,
|
|
1073
|
-
),
|
|
1074
|
-
},
|
|
1075
|
-
],
|
|
1076
|
-
traceOutput: is174 ? [] : captureOutput(getSpecInitialStates).lines,
|
|
1077
|
-
}
|
|
1078
|
-
: getTrace(index);
|
|
831
|
+
// TLC's states keep their own values, and coverage charges the cost model each value carries.
|
|
832
|
+
const canonicalizeState = coverage ? (state: Value[]) => state : createCanonicalizer();
|
|
833
|
+
|
|
834
|
+
const toRecord = search.toRecord;
|
|
835
|
+
const getUncoveredInitialStates = () =>
|
|
836
|
+
spec.init === undefined ? [] : getInitialStates(spec.init, environment, spec.scope);
|
|
837
|
+
const getSpecInitialStates = () =>
|
|
838
|
+
coverage ? getCoveredInitialStates() : getUncoveredInitialStates();
|
|
1079
839
|
const isUnfingerprintable = (state: Value[]) => {
|
|
1080
840
|
try {
|
|
1081
841
|
return getFingerprintState(state).some((value) => getFingerprintError(value) !== undefined);
|
|
@@ -1084,85 +844,112 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1084
844
|
return true;
|
|
1085
845
|
}
|
|
1086
846
|
};
|
|
1087
|
-
const
|
|
1088
|
-
|
|
1089
|
-
|
|
1090
|
-
|
|
1091
|
-
|
|
1092
|
-
|
|
1093
|
-
|
|
1094
|
-
|
|
1095
|
-
|
|
1096
|
-
|
|
1097
|
-
|
|
1098
|
-
}
|
|
1099
|
-
if (!failureOptions.callStack) {
|
|
1100
|
-
return failureOptions.isInitial ? getInitialExitCode(error) : getErrorExitCode(error);
|
|
1101
|
-
}
|
|
1102
|
-
if (failureOptions.isCallStackFirst) return getErrorExitCode(error);
|
|
1103
|
-
if (failureOptions.isLiveCallStack) {
|
|
1104
|
-
return (
|
|
1105
|
-
getExitCode(error) ?? (error instanceof TlaModuleError ? error.exitCode : EXIT_STATUS.error)
|
|
1106
|
-
);
|
|
1107
|
-
}
|
|
1108
|
-
return failureOptions.isInitial || failureOptions.fingerprint
|
|
1109
|
-
? EXIT_STATUS.specEvaluationFailure
|
|
1110
|
-
: getReplayExitCode(failureOptions.replayError ?? error);
|
|
847
|
+
const checkFailedTrace = (behavior: Behavior, counterExample?: CounterExampleOptions) => {
|
|
848
|
+
if (!counterExample) return { behavior, postcondition: undefined };
|
|
849
|
+
const checked = checkTracePostconditions(
|
|
850
|
+
behavior.trace,
|
|
851
|
+
undefined,
|
|
852
|
+
getStepAlias,
|
|
853
|
+
counterExample.isConsole,
|
|
854
|
+
);
|
|
855
|
+
return {
|
|
856
|
+
behavior: appendTraceOutput(behavior, checked.lines),
|
|
857
|
+
postcondition: checked.unwitnessed ?? checked.postcondition,
|
|
858
|
+
};
|
|
1111
859
|
};
|
|
1112
860
|
const createFailureResult = (
|
|
1113
861
|
failed: unknown,
|
|
1114
862
|
behavior: Behavior,
|
|
1115
863
|
failureOptions: FailureOptions = {},
|
|
864
|
+
postcondition?: Postcondition,
|
|
1116
865
|
) => {
|
|
1117
866
|
const error = isStackOverflow(failed) ? new TlaStackOverflowError() : failed;
|
|
1118
867
|
if (!(error instanceof TlaEvaluationError)) throw error;
|
|
1119
|
-
const checked =
|
|
1120
|
-
behavior.trace.length > 0 && !failureOptions.traceFailure
|
|
1121
|
-
? checkTracePostconditions(behavior.trace, undefined)
|
|
1122
|
-
: undefined;
|
|
1123
|
-
const postcondition = checked?.unwitnessed ?? checked?.postcondition;
|
|
1124
|
-
const traceOutput = [...(behavior.traceOutput ?? []), ...(checked?.lines ?? [])];
|
|
1125
868
|
return {
|
|
1126
869
|
...createResult("error", undefined, {
|
|
1127
|
-
...getFailureMessage(
|
|
870
|
+
...getFailureMessage(
|
|
871
|
+
error,
|
|
872
|
+
failureOptions.phase !== undefined && failureOptions.phase !== "initial",
|
|
873
|
+
),
|
|
1128
874
|
...behavior,
|
|
1129
|
-
...(traceOutput.length > 0 && { traceOutput }),
|
|
1130
875
|
...(postcondition && { postcondition }),
|
|
1131
876
|
initialState:
|
|
1132
877
|
failureOptions.initialState && !(error instanceof TlaModuleError)
|
|
1133
878
|
? toRecord(failureOptions.initialState)
|
|
1134
879
|
: undefined,
|
|
1135
|
-
exitCode: getFailureExitCode(error, failureOptions),
|
|
880
|
+
exitCode: getFailureExitCode(error, failureOptions, is174),
|
|
1136
881
|
callStack: failureOptions.callStack,
|
|
1137
|
-
...(failureOptions.
|
|
882
|
+
...(failureOptions.phase === "liveness" && { isCallStackFirst: true }),
|
|
1138
883
|
...(failureOptions.fingerprint && { fingerprint: failureOptions.fingerprint }),
|
|
1139
884
|
...(failureOptions.traceFailure && { traceFailure: failureOptions.traceFailure }),
|
|
1140
885
|
}),
|
|
1141
886
|
outDegrees: failureOptions.outDegrees,
|
|
1142
887
|
};
|
|
1143
888
|
};
|
|
1144
|
-
|
|
889
|
+
// Deviation from TLC: Worker#doPostCondition throws an ArrayIndexOutOfBoundsException at an incomplete successor, where tla-ts checks the postconditions with the successor in CounterExample.
|
|
890
|
+
const reportIncompleteSuccessor = (
|
|
891
|
+
index: number,
|
|
892
|
+
error: TlaIncompleteSuccessorError,
|
|
893
|
+
liveSuccessors: LiveSuccessor[],
|
|
894
|
+
) => {
|
|
1145
895
|
runtime.generatedStates++;
|
|
1146
|
-
const
|
|
1147
|
-
|
|
1148
|
-
|
|
1149
|
-
|
|
1150
|
-
|
|
1151
|
-
|
|
1152
|
-
|
|
1153
|
-
|
|
1154
|
-
|
|
1155
|
-
|
|
1156
|
-
|
|
896
|
+
const found = captureOutput(() => {
|
|
897
|
+
try {
|
|
898
|
+
return {
|
|
899
|
+
action: coverage
|
|
900
|
+
? coverageActions.find((item) => hasCoveredIncompleteSuccessor(item, states[index]))
|
|
901
|
+
: nextActions.find((item) =>
|
|
902
|
+
hasIncompleteSuccessor(item.expression, states[index], environment, item.scope),
|
|
903
|
+
),
|
|
904
|
+
failed: undefined,
|
|
905
|
+
};
|
|
906
|
+
} catch (failed) {
|
|
907
|
+
if (!(failed instanceof TlaEvaluationError)) throw failed;
|
|
908
|
+
return { action: undefined, failed };
|
|
909
|
+
}
|
|
910
|
+
});
|
|
911
|
+
const action = found.result.action;
|
|
912
|
+
const traceFailure = found.result.failed && getTraceFailure(found.result.failed, found.lines);
|
|
1157
913
|
const message = getIncompleteSuccessorMessage(
|
|
1158
914
|
error.variables,
|
|
1159
915
|
error.action,
|
|
1160
|
-
|
|
916
|
+
nextActions.length,
|
|
1161
917
|
options.version,
|
|
1162
918
|
);
|
|
1163
|
-
const
|
|
1164
|
-
const
|
|
1165
|
-
|
|
919
|
+
const live = captureOutput(() => addFailedLiveState(index, liveSuccessors));
|
|
920
|
+
const trace = traces.getStateTrace(index, {
|
|
921
|
+
incomplete: error.state,
|
|
922
|
+
isPrintedOnly: true,
|
|
923
|
+
}).trace;
|
|
924
|
+
const checked = checkFailedTrace(
|
|
925
|
+
appendTraceOutput(
|
|
926
|
+
{
|
|
927
|
+
trace: traceFailure
|
|
928
|
+
? trace
|
|
929
|
+
: [
|
|
930
|
+
...trace,
|
|
931
|
+
traces.getIncompleteStep(
|
|
932
|
+
error.state,
|
|
933
|
+
trace.length + 1,
|
|
934
|
+
{
|
|
935
|
+
action: error.action,
|
|
936
|
+
label: action && getActionLabel(action, options.version),
|
|
937
|
+
output: found.lines,
|
|
938
|
+
},
|
|
939
|
+
action,
|
|
940
|
+
),
|
|
941
|
+
],
|
|
942
|
+
},
|
|
943
|
+
live.lines,
|
|
944
|
+
),
|
|
945
|
+
{ isConsole: true },
|
|
946
|
+
);
|
|
947
|
+
const failure = createFailureResult(
|
|
948
|
+
error,
|
|
949
|
+
checked.behavior,
|
|
950
|
+
{ callStack: live.result, traceFailure },
|
|
951
|
+
checked.postcondition,
|
|
952
|
+
);
|
|
1166
953
|
return withOutDegrees({
|
|
1167
954
|
...failure,
|
|
1168
955
|
failure: failure.failure && {
|
|
@@ -1171,79 +958,18 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1171
958
|
message,
|
|
1172
959
|
toolMessage: message,
|
|
1173
960
|
exitCode: EXIT_STATUS.specEvaluationFailure,
|
|
1174
|
-
trace: [
|
|
1175
|
-
...failure.failure.trace,
|
|
1176
|
-
{
|
|
1177
|
-
action: error.action,
|
|
1178
|
-
label: action && getActionLabel(action, options.version),
|
|
1179
|
-
state: toRecord(partial),
|
|
1180
|
-
},
|
|
1181
|
-
],
|
|
1182
961
|
},
|
|
1183
962
|
});
|
|
1184
963
|
};
|
|
1185
|
-
const getPathSteps = (path: number[], loopStart?: number) => {
|
|
1186
|
-
const steps = getPathStates(path, NEXT_RECOVERY_FAILURE);
|
|
1187
|
-
const lastState = steps[steps.length - 1].state;
|
|
1188
|
-
const isClosed =
|
|
1189
|
-
!isReducing ||
|
|
1190
|
-
loopStart === undefined ||
|
|
1191
|
-
loopStart === path.length - 1 ||
|
|
1192
|
-
findSuccessorWithFingerprint(lastState, path[loopStart]) !== undefined;
|
|
1193
|
-
if (!isClosed) throw new TlaEvaluationError(NEXT_RECOVERY_FAILURE);
|
|
1194
|
-
return steps;
|
|
1195
|
-
};
|
|
1196
|
-
const getStateHash = (state: Value[]) => {
|
|
1197
|
-
let hash = 0x811c9dc5;
|
|
1198
|
-
for (let index = 0; index < state.length; index++)
|
|
1199
|
-
hash = combineHash(hash, getValueHash(state[index]));
|
|
1200
|
-
return hash & 0x3fffffff;
|
|
1201
|
-
};
|
|
1202
964
|
const fingerprintModelState = (state: Value[]) => {
|
|
1203
965
|
for (const value of state) {
|
|
1204
966
|
const error = getFingerprintError(value);
|
|
1205
967
|
if (error) throw error;
|
|
1206
968
|
}
|
|
1207
969
|
};
|
|
1208
|
-
const isSameState = (stored: Value[], state: Value[]) => {
|
|
1209
|
-
for (let position = 0; position < state.length; position++) {
|
|
1210
|
-
if (!isSameValue(stored[position], state[position])) return false;
|
|
1211
|
-
}
|
|
1212
|
-
return true;
|
|
1213
|
-
};
|
|
1214
|
-
const getSlot = (hash: number) => (Math.imul(hash, 0x9e3779b1) >>> seenStates.shift) << 1;
|
|
1215
|
-
const findStateIndex = (hash: number, state: Value[]) => {
|
|
1216
|
-
const mask = seenStates.slots.length - 1;
|
|
1217
|
-
for (let slot = getSlot(hash); ; slot = (slot + 2) & mask) {
|
|
1218
|
-
const entry = seenStates.slots[slot + 1];
|
|
1219
|
-
if (entry === 0) return -1;
|
|
1220
|
-
if (seenStates.slots[slot] === hash && isSameState(fingerprintStates[entry - 1], state)) {
|
|
1221
|
-
return entry - 1;
|
|
1222
|
-
}
|
|
1223
|
-
}
|
|
1224
|
-
};
|
|
1225
|
-
const insertSeen = (hash: number, entry: number) => {
|
|
1226
|
-
const mask = seenStates.slots.length - 1;
|
|
1227
|
-
let slot = getSlot(hash);
|
|
1228
|
-
while (seenStates.slots[slot + 1] !== 0) slot = (slot + 2) & mask;
|
|
1229
|
-
seenStates.slots[slot] = hash;
|
|
1230
|
-
seenStates.slots[slot + 1] = entry;
|
|
1231
|
-
};
|
|
1232
|
-
const markSeen = (hash: number, index: number) => {
|
|
1233
|
-
seenStates.size++;
|
|
1234
|
-
if (seenStates.size * 4 > seenStates.slots.length) {
|
|
1235
|
-
const slots = seenStates.slots;
|
|
1236
|
-
seenStates.slots = new Int32Array(slots.length * 2);
|
|
1237
|
-
seenStates.shift--;
|
|
1238
|
-
for (let slot = 0; slot < slots.length; slot += 2) {
|
|
1239
|
-
if (slots[slot + 1] !== 0) insertSeen(slots[slot], slots[slot + 1]);
|
|
1240
|
-
}
|
|
1241
|
-
}
|
|
1242
|
-
insertSeen(hash, index + 1);
|
|
1243
|
-
};
|
|
1244
970
|
let unstoredFingerprint: Value[] | undefined;
|
|
1245
971
|
const countDistinctState = (depth: number) => {
|
|
1246
|
-
runtime.distinctStates = states.length + 1;
|
|
972
|
+
runtime.distinctStates = states.length + exploredStates.length + 1;
|
|
1247
973
|
searchDepth = Math.max(searchDepth, depth);
|
|
1248
974
|
runtime.diameter = Math.max(runtime.diameter, depth);
|
|
1249
975
|
};
|
|
@@ -1269,17 +995,50 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1269
995
|
livenessSource: -1,
|
|
1270
996
|
rebuilt: undefined,
|
|
1271
997
|
};
|
|
998
|
+
const traces = createTraceBuilder({
|
|
999
|
+
config,
|
|
1000
|
+
options,
|
|
1001
|
+
environment,
|
|
1002
|
+
search,
|
|
1003
|
+
nextActions,
|
|
1004
|
+
current,
|
|
1005
|
+
states,
|
|
1006
|
+
fingerprintStates,
|
|
1007
|
+
parents,
|
|
1008
|
+
actions,
|
|
1009
|
+
depths,
|
|
1010
|
+
tracedSteps,
|
|
1011
|
+
captureOutput,
|
|
1012
|
+
getInitialStates: getSpecInitialStates,
|
|
1013
|
+
getUncoveredInitialStates,
|
|
1014
|
+
findSuccessorAction,
|
|
1015
|
+
});
|
|
1272
1016
|
const getPath = (index: number): Value[][] =>
|
|
1273
1017
|
index === -1 ? [] : [...getPath(parents[index]), states[index]];
|
|
1018
|
+
// TLC adds a successor's fingerprint to its set before it checks the invariants of the successor.
|
|
1274
1019
|
runtime.isSeen = (state) => {
|
|
1275
1020
|
const fingerprintState = getFingerprintState(state);
|
|
1276
|
-
|
|
1021
|
+
const hash = getStateHash(fingerprintState);
|
|
1022
|
+
return (
|
|
1023
|
+
findStateIndex(seenStates, hash, fingerprintState) !== -1 ||
|
|
1024
|
+
isExplored(hash, fingerprintState) ||
|
|
1025
|
+
(unstoredFingerprint !== undefined && isSameState(unstoredFingerprint, fingerprintState))
|
|
1026
|
+
);
|
|
1027
|
+
};
|
|
1028
|
+
runtime.markExplored = (state) => {
|
|
1029
|
+
const fingerprintState = getFingerprintState(state);
|
|
1030
|
+
exploredTable ??= createStateTable(exploredFingerprintStates);
|
|
1031
|
+
markSeenState(exploredTable, getStateHash(fingerprintState), exploredStates.length);
|
|
1032
|
+
exploredStates.push(state);
|
|
1033
|
+
exploredFingerprintStates.push(fingerprintState);
|
|
1034
|
+
runtime.distinctStates++;
|
|
1277
1035
|
};
|
|
1278
1036
|
runtime.getBehavior = (state) => {
|
|
1279
1037
|
const index = state === current.candidate ? -1 : states.indexOf(state);
|
|
1280
1038
|
return index === -1 ? [...getPath(current.index), state] : getPath(index);
|
|
1281
1039
|
};
|
|
1282
|
-
runtime.getCurrentState = () =>
|
|
1040
|
+
runtime.getCurrentState = () =>
|
|
1041
|
+
current.rebuilt?.state ?? (current.index === -1 ? undefined : states[current.index]);
|
|
1283
1042
|
runtime.setLivenessSource = (index) => {
|
|
1284
1043
|
current.livenessSource = index ?? -1;
|
|
1285
1044
|
};
|
|
@@ -1309,26 +1068,27 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1309
1068
|
formatState(
|
|
1310
1069
|
config.alias === undefined
|
|
1311
1070
|
? toRecord(state)
|
|
1312
|
-
: evaluateAlias(config.alias, state, undefined),
|
|
1071
|
+
: search.evaluateAlias(config.alias, state, undefined, options.isTool ?? false),
|
|
1313
1072
|
),
|
|
1314
1073
|
getText: () => formatState(toRecord(state)),
|
|
1315
1074
|
});
|
|
1316
1075
|
|
|
1317
1076
|
const visitInitialState = (state: Value[]) => {
|
|
1318
|
-
canonicalizeState(state);
|
|
1319
1077
|
runtime.generatedStates++;
|
|
1320
1078
|
runtime.initialStates++;
|
|
1321
1079
|
current.candidate = state;
|
|
1322
1080
|
current.candidateLevel = 1;
|
|
1323
|
-
const fingerprintState = getFingerprintState(state);
|
|
1324
|
-
const hash = getStateHash(fingerprintState);
|
|
1325
1081
|
const isInModel = search.satisfiesConstraints(state);
|
|
1082
|
+
// TLC fingerprints only a state in the model, which sorts its records in place.
|
|
1083
|
+
if (isInModel) canonicalizeState(state);
|
|
1084
|
+
const fingerprintState = isInModel ? getFingerprintState(state) : state;
|
|
1085
|
+
const hash = isInModel ? getStateHash(fingerprintState) : 0;
|
|
1326
1086
|
if (isInModel) {
|
|
1327
1087
|
search.trackStatePossible(state);
|
|
1328
1088
|
fingerprintModelState(fingerprintState);
|
|
1329
1089
|
state.forEach(markFingerprinted);
|
|
1330
1090
|
}
|
|
1331
|
-
const isSeen = isInModel && findStateIndex(hash, fingerprintState) !== -1;
|
|
1091
|
+
const isSeen = isInModel && findStateIndex(seenStates, hash, fingerprintState) !== -1;
|
|
1332
1092
|
if (isSeen) return undefined;
|
|
1333
1093
|
unstoredFingerprint = isInModel ? fingerprintState : undefined;
|
|
1334
1094
|
if (isInModel) {
|
|
@@ -1338,32 +1098,56 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1338
1098
|
stateWriter?.writeInitialState(getGraphState(state, 1));
|
|
1339
1099
|
}
|
|
1340
1100
|
if (options.isContinued) {
|
|
1341
|
-
search.
|
|
1101
|
+
search.forEachViolatedInvariant(state, (invariant) =>
|
|
1342
1102
|
reportContinuedViolation("invariant-violation", {
|
|
1343
1103
|
name: invariant.name,
|
|
1344
|
-
...toTrace([{ action: undefined, state }], []),
|
|
1104
|
+
...traces.toTrace([{ action: undefined, state }], []),
|
|
1345
1105
|
}),
|
|
1346
1106
|
);
|
|
1347
1107
|
}
|
|
1348
1108
|
const violated = options.isContinued ? undefined : search.findViolatedInvariant(state);
|
|
1349
1109
|
if (violated) {
|
|
1350
|
-
return reportViolation(
|
|
1351
|
-
|
|
1352
|
-
...toTrace([{ action: undefined, state }], []),
|
|
1353
|
-
|
|
1110
|
+
return reportViolation(
|
|
1111
|
+
"invariant-violation",
|
|
1112
|
+
{ name: violated.name, ...traces.toTrace([{ action: undefined, state }], []) },
|
|
1113
|
+
getStepState,
|
|
1114
|
+
);
|
|
1354
1115
|
}
|
|
1355
1116
|
const failedPredicate = search.findFailedInitialPredicate(state);
|
|
1356
1117
|
if (failedPredicate) {
|
|
1357
|
-
return reportViolation(
|
|
1358
|
-
|
|
1359
|
-
...toTrace([{ action: undefined, state }], []),
|
|
1360
|
-
|
|
1118
|
+
return reportViolation(
|
|
1119
|
+
"liveness-violation",
|
|
1120
|
+
{ name: failedPredicate.name, ...traces.toTrace([{ action: undefined, state }], []) },
|
|
1121
|
+
getStepState,
|
|
1122
|
+
);
|
|
1361
1123
|
}
|
|
1362
1124
|
if (!isInModel) return undefined;
|
|
1363
|
-
|
|
1125
|
+
markSeenState(seenStates, hash, states.length);
|
|
1364
1126
|
addState(state, fingerprintState, -1, undefined);
|
|
1365
1127
|
return undefined;
|
|
1366
1128
|
};
|
|
1129
|
+
// Looks a successor up, where the constraints keep it in the model, as the search does before it
|
|
1130
|
+
// checks the successor.
|
|
1131
|
+
const lookUpSuccessor = (state: Value[], successor: Successor) => {
|
|
1132
|
+
const isStateInModel = search.satisfiesConstraints(successor.state, state);
|
|
1133
|
+
if (isStateInModel) search.trackStatePossible(successor.state);
|
|
1134
|
+
const isInModel = isStateInModel && search.satisfiesActionConstraints(state, successor.state);
|
|
1135
|
+
const fingerprintState = isInModel ? getFingerprintState(successor.state) : successor.state;
|
|
1136
|
+
const hash = isInModel ? getStateHash(fingerprintState) : 0;
|
|
1137
|
+
if (isInModel) {
|
|
1138
|
+
search.trackActionPossible(state, successor.state);
|
|
1139
|
+
fingerprintModelState(fingerprintState);
|
|
1140
|
+
successor.state.forEach(markFingerprinted);
|
|
1141
|
+
}
|
|
1142
|
+
const existing = isInModel ? findStateIndex(seenStates, hash, fingerprintState) : -1;
|
|
1143
|
+
return {
|
|
1144
|
+
fingerprintState,
|
|
1145
|
+
hash,
|
|
1146
|
+
isInModel,
|
|
1147
|
+
existing,
|
|
1148
|
+
isSeen: existing !== -1 || (isInModel && isExplored(hash, fingerprintState)),
|
|
1149
|
+
};
|
|
1150
|
+
};
|
|
1367
1151
|
const visitSuccessor = (
|
|
1368
1152
|
index: number,
|
|
1369
1153
|
successor: Successor,
|
|
@@ -1376,27 +1160,16 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1376
1160
|
current.candidate = successor.state;
|
|
1377
1161
|
current.candidateLevel = depths[index] + 1;
|
|
1378
1162
|
if (isCanonicalizedFirst) canonicalizeState(successor.state);
|
|
1379
|
-
const
|
|
1380
|
-
|
|
1381
|
-
const foundIndex = findStateIndex(hash, fingerprintState);
|
|
1382
|
-
const isStateInModel = search.satisfiesConstraints(successor.state, state);
|
|
1383
|
-
if (isStateInModel) search.trackStatePossible(successor.state);
|
|
1384
|
-
const isInModel = isStateInModel && search.satisfiesActionConstraints(state, successor.state);
|
|
1385
|
-
if (isInModel) {
|
|
1386
|
-
search.trackActionPossible(state, successor.state);
|
|
1387
|
-
fingerprintModelState(fingerprintState);
|
|
1388
|
-
successor.state.forEach(markFingerprinted);
|
|
1389
|
-
}
|
|
1390
|
-
const existing = isInModel ? foundIndex : -1;
|
|
1391
|
-
if (source && isInModel) {
|
|
1163
|
+
const found = lookUpSuccessor(state, successor);
|
|
1164
|
+
if (source && found.isInModel) {
|
|
1392
1165
|
stateWriter?.writeSuccessor(
|
|
1393
1166
|
source,
|
|
1394
1167
|
getGraphState(successor.state, depths[index] + 1),
|
|
1395
|
-
|
|
1168
|
+
found.isSeen,
|
|
1396
1169
|
action && getGraphAction(action),
|
|
1397
1170
|
);
|
|
1398
1171
|
}
|
|
1399
|
-
if (source && !isInModel && options.dump?.constrained) {
|
|
1172
|
+
if (source && !found.isInModel && options.dump?.constrained) {
|
|
1400
1173
|
const excluded = getGraphState(successor.state, depths[index] + 1);
|
|
1401
1174
|
search
|
|
1402
1175
|
.getExcludingConstraints(state, successor.state)
|
|
@@ -1409,33 +1182,45 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1409
1182
|
),
|
|
1410
1183
|
);
|
|
1411
1184
|
}
|
|
1412
|
-
if (existing !== -1 && liveness) {
|
|
1413
|
-
const stored = states[existing];
|
|
1185
|
+
if (found.existing !== -1 && liveness) {
|
|
1186
|
+
const stored = states[found.existing];
|
|
1414
1187
|
const isStored = stored.every((value, position) => value === successor.state[position]);
|
|
1415
|
-
liveSuccessors.push({ index: existing, state: isStored ? stored : successor.state });
|
|
1188
|
+
liveSuccessors.push({ index: found.existing, state: isStored ? stored : successor.state });
|
|
1416
1189
|
}
|
|
1417
|
-
|
|
1190
|
+
if (found.isSeen && found.existing === -1 && liveness) {
|
|
1191
|
+
liveSuccessors.push({
|
|
1192
|
+
index: getPendingIndex(found.hash, found.fingerprintState),
|
|
1193
|
+
state: successor.state,
|
|
1194
|
+
});
|
|
1195
|
+
}
|
|
1196
|
+
const isNew = found.isInModel && !found.isSeen;
|
|
1418
1197
|
if (isNew && liveness) liveSuccessors.push({ index: states.length, state: successor.state });
|
|
1419
|
-
unstoredFingerprint = isNew ? fingerprintState : undefined;
|
|
1198
|
+
unstoredFingerprint = isNew ? found.fingerprintState : undefined;
|
|
1420
1199
|
if (isNew) {
|
|
1421
1200
|
countDistinctState(depths[index] + 1);
|
|
1422
1201
|
newStateCount++;
|
|
1423
1202
|
if (coverage) coverage.secondary[coveredNode]++;
|
|
1424
1203
|
}
|
|
1425
|
-
if (
|
|
1204
|
+
if (!found.isSeen) {
|
|
1426
1205
|
try {
|
|
1427
1206
|
const violated = search.findViolatedInvariant(successor.state, state);
|
|
1428
|
-
const violation = violated && {
|
|
1207
|
+
const violation = violated && {
|
|
1208
|
+
name: violated.name,
|
|
1209
|
+
...traces.getTrace(index, successor, { isPrintedOnly: options.isContinued }),
|
|
1210
|
+
};
|
|
1429
1211
|
if (violation && !options.isContinued) {
|
|
1430
1212
|
return withOutDegrees(reportViolation("invariant-violation", violation));
|
|
1431
1213
|
}
|
|
1432
1214
|
if (violation) reportContinuedViolation("invariant-violation", violation);
|
|
1433
1215
|
} catch (error) {
|
|
1434
1216
|
if (isStackOverflow(error)) throw error;
|
|
1435
|
-
const
|
|
1217
|
+
const behavior = traces.getTrace(index, successor, { isPrintedOnly: true });
|
|
1218
|
+
const replay = is174
|
|
1219
|
+
? captureOutput(() => replayNext(index))
|
|
1220
|
+
: replayFailedNext(index, liveSuccessors);
|
|
1436
1221
|
return createFailureResult(
|
|
1437
1222
|
error,
|
|
1438
|
-
appendTraceOutput(
|
|
1223
|
+
appendTraceOutput(behavior, replay.lines),
|
|
1439
1224
|
replay.result ?? { outDegrees: getFailureOutDegrees() },
|
|
1440
1225
|
);
|
|
1441
1226
|
}
|
|
@@ -1443,7 +1228,7 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1443
1228
|
const violatedProperty = search.findViolatedActionProperty(state, successor.state);
|
|
1444
1229
|
const propertyViolation = violatedProperty && {
|
|
1445
1230
|
name: violatedProperty.name,
|
|
1446
|
-
...getTrace(index, successor),
|
|
1231
|
+
...traces.getTrace(index, successor, { isPrintedOnly: options.isContinued }),
|
|
1447
1232
|
};
|
|
1448
1233
|
if (propertyViolation && !options.isContinued) {
|
|
1449
1234
|
return withOutDegrees(reportViolation("liveness-violation", propertyViolation));
|
|
@@ -1452,8 +1237,12 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1452
1237
|
if (!isNew) return undefined;
|
|
1453
1238
|
if (coverage) countCoverageVariables(coverage, successor.state);
|
|
1454
1239
|
if (!isCanonicalizedFirst) canonicalizeState(successor.state);
|
|
1455
|
-
|
|
1456
|
-
|
|
1240
|
+
markSeenState(seenStates, found.hash, states.length);
|
|
1241
|
+
if (pendingStates) {
|
|
1242
|
+
const pending = findStateIndex(pendingStates, found.hash, found.fingerprintState);
|
|
1243
|
+
if (pending !== -1) liveness?.storeState(-2 - pending, states.length);
|
|
1244
|
+
}
|
|
1245
|
+
addState(successor.state, found.fingerprintState, index, successor.action);
|
|
1457
1246
|
runtime.queueSize++;
|
|
1458
1247
|
return undefined;
|
|
1459
1248
|
};
|
|
@@ -1466,6 +1255,57 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1466
1255
|
const assumptionViolation = findViolatedAssumption();
|
|
1467
1256
|
if (assumptionViolation) return createResult("assumption-violation", assumptionViolation);
|
|
1468
1257
|
options.onProgress?.({ kind: "initial-states-started" });
|
|
1258
|
+
const typedChecks =
|
|
1259
|
+
!options.isContinued &&
|
|
1260
|
+
options.dump === undefined &&
|
|
1261
|
+
// A set of small integers on the tier is a 31-bit mask, which a lower bound could overflow.
|
|
1262
|
+
options.maxSetSize === undefined &&
|
|
1263
|
+
!hasPostconditions
|
|
1264
|
+
? search.getTypedChecks(liveness?.solutions)
|
|
1265
|
+
: undefined;
|
|
1266
|
+
const typed =
|
|
1267
|
+
typedChecks &&
|
|
1268
|
+
runTypedSearch(environment, {
|
|
1269
|
+
...typedChecks,
|
|
1270
|
+
isDeadlockChecked: config.checkDeadlock,
|
|
1271
|
+
isFingerprinted: !options.isFingerprintDistanceSkipped,
|
|
1272
|
+
livenessCheck: options.livenessCheck ?? "default",
|
|
1273
|
+
});
|
|
1274
|
+
if (typed && !typed.deadlock && !typed.violation && !typed.lasso) {
|
|
1275
|
+
for (let count = 2; count < typed.initialStates.generated; count *= 2) {
|
|
1276
|
+
reportInitialStatesProgress(count, options.onProgress);
|
|
1277
|
+
}
|
|
1278
|
+
options.onProgress?.({ kind: "initial-states-computed", initialStates: typed.initialStates });
|
|
1279
|
+
const statistics = {
|
|
1280
|
+
...createResult("success"),
|
|
1281
|
+
generatedStates: typed.generatedStates,
|
|
1282
|
+
distinctStates: typed.distinctStates,
|
|
1283
|
+
queuedStates: 0,
|
|
1284
|
+
depth: typed.generatedStates === 0 ? 0 : Math.max(typed.depth, 1),
|
|
1285
|
+
initialStates: typed.initialStates,
|
|
1286
|
+
};
|
|
1287
|
+
if (liveness && options.livenessCheck !== "off") {
|
|
1288
|
+
options.onProgress?.({
|
|
1289
|
+
kind: "liveness-started",
|
|
1290
|
+
branches: liveness.branches,
|
|
1291
|
+
isComplete: true,
|
|
1292
|
+
states: liveness.branches * typed.distinctStates,
|
|
1293
|
+
statistics,
|
|
1294
|
+
});
|
|
1295
|
+
options.onProgress?.({ kind: "liveness-finished" });
|
|
1296
|
+
}
|
|
1297
|
+
return {
|
|
1298
|
+
...statistics,
|
|
1299
|
+
outDegrees: typed.outDegrees,
|
|
1300
|
+
fingerprintDistance: options.isFingerprintDistanceSkipped
|
|
1301
|
+
? undefined
|
|
1302
|
+
: getFingerprintDistance(
|
|
1303
|
+
typed.distinctStates,
|
|
1304
|
+
typed.generatedStates,
|
|
1305
|
+
typed.forEachFingerprintRun,
|
|
1306
|
+
),
|
|
1307
|
+
};
|
|
1308
|
+
}
|
|
1469
1309
|
if (spec.init !== undefined) {
|
|
1470
1310
|
let overflowState: Value[] | undefined;
|
|
1471
1311
|
const reportInitialFailure = (error: unknown, state: Value[]) => {
|
|
@@ -1473,7 +1313,7 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1473
1313
|
return createFailureResult(
|
|
1474
1314
|
error,
|
|
1475
1315
|
{ trace: [], traceOutput: replay.lines },
|
|
1476
|
-
{ initialState: state, ...replay.result,
|
|
1316
|
+
{ initialState: state, ...replay.result, phase: "initial" },
|
|
1477
1317
|
);
|
|
1478
1318
|
};
|
|
1479
1319
|
try {
|
|
@@ -1500,9 +1340,7 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1500
1340
|
(state) => {
|
|
1501
1341
|
if (onInitialState(state)) throw STOP_WALK;
|
|
1502
1342
|
},
|
|
1503
|
-
|
|
1504
|
-
throw setExitCode(new TlaIllegalStateError([...partial]), EXIT_STATUS.error);
|
|
1505
|
-
},
|
|
1343
|
+
rejectIncompleteInitialState,
|
|
1506
1344
|
);
|
|
1507
1345
|
} catch (error) {
|
|
1508
1346
|
if (error !== STOP_WALK) throw error;
|
|
@@ -1515,21 +1353,36 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1515
1353
|
}
|
|
1516
1354
|
} catch (error) {
|
|
1517
1355
|
if (error instanceof TlaIllegalStateError) {
|
|
1356
|
+
reportInitialStatesProgress(runtime.initialStates, options.onProgress);
|
|
1357
|
+
runtime.generatedStates++;
|
|
1358
|
+
runtime.initialStates++;
|
|
1359
|
+
const state = error.state.map((value) => value ?? createModelValue("null"));
|
|
1360
|
+
// Deviation from TLC: CounterExample holds a Java null for an unassigned variable and leaks a NullPointerException, where tla-ts binds the model value null.
|
|
1361
|
+
const checked = checkTracePostconditions(
|
|
1362
|
+
[{ action: undefined, label: undefined, state: toRecord(state) }],
|
|
1363
|
+
undefined,
|
|
1364
|
+
getStepState,
|
|
1365
|
+
);
|
|
1366
|
+
const postcondition = checked.unwitnessed ?? checked.postcondition;
|
|
1518
1367
|
const illegal = createFailureResult(
|
|
1519
1368
|
error,
|
|
1520
|
-
{ trace: [] },
|
|
1521
|
-
{ initialState:
|
|
1369
|
+
{ trace: [], traceOutput: checked.lines },
|
|
1370
|
+
{ initialState: state },
|
|
1522
1371
|
);
|
|
1523
1372
|
return {
|
|
1524
1373
|
...illegal,
|
|
1525
|
-
failure: illegal.failure && {
|
|
1374
|
+
failure: illegal.failure && {
|
|
1375
|
+
...illegal.failure,
|
|
1376
|
+
isWithoutStatistics: true,
|
|
1377
|
+
...(postcondition && { postcondition }),
|
|
1378
|
+
},
|
|
1526
1379
|
};
|
|
1527
1380
|
}
|
|
1528
1381
|
const replay = captureOutput(replayInit);
|
|
1529
1382
|
return createFailureResult(
|
|
1530
1383
|
error,
|
|
1531
1384
|
{ trace: [], traceOutput: replay.lines },
|
|
1532
|
-
{ ...replay.result,
|
|
1385
|
+
{ ...replay.result, phase: "initial" },
|
|
1533
1386
|
);
|
|
1534
1387
|
}
|
|
1535
1388
|
}
|
|
@@ -1567,7 +1420,7 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1567
1420
|
try {
|
|
1568
1421
|
coverageActions.forEach((action) => {
|
|
1569
1422
|
coveredNode = action.node;
|
|
1570
|
-
walkCoveredSuccessors(action, state, (successor) => {
|
|
1423
|
+
walkCoveredSuccessors(coverage, action, state, environment, (successor) => {
|
|
1571
1424
|
successorCount++;
|
|
1572
1425
|
if (onSuccessor({ state: successor, action: action.name }, action)) throw STOP_WALK;
|
|
1573
1426
|
});
|
|
@@ -1589,7 +1442,7 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1589
1442
|
);
|
|
1590
1443
|
}
|
|
1591
1444
|
let isStopped = false;
|
|
1592
|
-
return
|
|
1445
|
+
return nextActions.reduce((count, action) => {
|
|
1593
1446
|
if (isStopped) return count;
|
|
1594
1447
|
return (
|
|
1595
1448
|
count +
|
|
@@ -1608,9 +1461,10 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1608
1461
|
);
|
|
1609
1462
|
}, 0);
|
|
1610
1463
|
};
|
|
1464
|
+
// Deviation from TLC: Worker#doNextCheckLiveness doesn't catch a FingerprintException from its rerun, so TLC prints the behavior without the failure.
|
|
1611
1465
|
const getLiveCallStack = (index: number, liveSuccessors: LiveSuccessor[]) => {
|
|
1612
1466
|
if (!liveness || is174) return undefined;
|
|
1613
|
-
const replay = getReplayFailure((tracing) =>
|
|
1467
|
+
const replay = getReplayFailure(environment, (tracing) =>
|
|
1614
1468
|
liveness.addState(index, states[index], liveSuccessors, tracing),
|
|
1615
1469
|
);
|
|
1616
1470
|
return replay?.callStack.length && !replay.fingerprint ? replay.callStack : undefined;
|
|
@@ -1621,33 +1475,103 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1621
1475
|
return undefined;
|
|
1622
1476
|
} catch (error) {
|
|
1623
1477
|
if (!(error instanceof TlaEvaluationError)) throw error;
|
|
1478
|
+
// TLC fails to fingerprint an incomplete successor with an exception Worker#doNextCheckLiveness doesn't rerun for a call stack.
|
|
1479
|
+
if (error instanceof TlaIncompleteSuccessorError) return undefined;
|
|
1624
1480
|
return getLiveCallStack(index, liveSuccessors);
|
|
1625
1481
|
}
|
|
1626
1482
|
};
|
|
1627
1483
|
const replayFailedNext = (index: number, liveSuccessors: LiveSuccessor[]) => {
|
|
1628
1484
|
const live = captureOutput(() => addFailedLiveState(index, liveSuccessors));
|
|
1629
1485
|
if (live.result) {
|
|
1630
|
-
const result = { callStack: live.result
|
|
1486
|
+
const result: FailureOptions = { phase: "behavior-graph", callStack: live.result };
|
|
1631
1487
|
return { result, lines: live.lines };
|
|
1632
1488
|
}
|
|
1633
1489
|
const replay = captureOutput(() => replayNext(index));
|
|
1634
|
-
|
|
1490
|
+
const result: FailureOptions =
|
|
1491
|
+
replay.result ?? (is174 ? {} : { outDegrees: getFailureOutDegrees() });
|
|
1492
|
+
return { result, lines: [...live.lines, ...replay.lines] };
|
|
1635
1493
|
};
|
|
1636
|
-
const
|
|
1637
|
-
|
|
1494
|
+
const getNextFailureTrace = (index: number, counterExample?: CounterExampleOptions) =>
|
|
1495
|
+
checkFailedTrace(
|
|
1496
|
+
traces.getStateTrace(index, { isPrintedOnly: !counterExample }),
|
|
1497
|
+
counterExample,
|
|
1498
|
+
);
|
|
1499
|
+
const reportNextStateOverflow = (index: number, counterExample?: CounterExampleOptions) => {
|
|
1500
|
+
const checked = getNextFailureTrace(index, counterExample);
|
|
1501
|
+
return createFailureResult(
|
|
1502
|
+
createStackOverflowError(),
|
|
1503
|
+
checked.behavior,
|
|
1504
|
+
{ phase: "next" },
|
|
1505
|
+
checked.postcondition,
|
|
1506
|
+
);
|
|
1507
|
+
};
|
|
1508
|
+
// Deviation from TLC: under -continue, TLC's Worker reports a state whose next-state relation failed as deadlocked, or else reports the failure twice as its replay fails again.
|
|
1509
|
+
// Deviation from TLC: under -continue, ModelChecker#doNextEvalFailed rethrows a failed invariant to Worker#doNextFailed, which reports it again with the code of its error.
|
|
1638
1510
|
const reportNextStateFailure = (
|
|
1639
1511
|
error: unknown,
|
|
1640
1512
|
index: number,
|
|
1641
1513
|
liveSuccessors: LiveSuccessor[],
|
|
1514
|
+
generated: number,
|
|
1642
1515
|
) => {
|
|
1643
|
-
|
|
1516
|
+
// TLC's Worker goes on to find a state without successors deadlocked after it fails, which checks the postconditions.
|
|
1517
|
+
const counterExample =
|
|
1518
|
+
config.checkDeadlock && runtime.generatedStates === generated
|
|
1519
|
+
? { isConsole: false }
|
|
1520
|
+
: undefined;
|
|
1521
|
+
if (isStackOverflow(error)) return reportNextStateOverflow(index, counterExample);
|
|
1522
|
+
const checked = getNextFailureTrace(index, counterExample);
|
|
1644
1523
|
const replay = replayFailedNext(index, liveSuccessors);
|
|
1645
1524
|
return createFailureResult(
|
|
1646
1525
|
withNextStateExitCode(error),
|
|
1647
|
-
appendTraceOutput(
|
|
1648
|
-
{
|
|
1526
|
+
appendTraceOutput(checked.behavior, replay.lines),
|
|
1527
|
+
{ phase: "next", ...replay.result },
|
|
1528
|
+
checked.postcondition,
|
|
1649
1529
|
);
|
|
1650
1530
|
};
|
|
1531
|
+
const addLiveState = (
|
|
1532
|
+
index: number,
|
|
1533
|
+
liveSuccessors: LiveSuccessor[],
|
|
1534
|
+
source: GraphState | undefined,
|
|
1535
|
+
) => {
|
|
1536
|
+
if (liveness && source && (is174 || options.dump?.stuttering)) {
|
|
1537
|
+
stateWriter?.writeStuttering(source);
|
|
1538
|
+
}
|
|
1539
|
+
const accepted = liveness?.addState(index, states[index], liveSuccessors);
|
|
1540
|
+
if (!liveness || !accepted) return undefined;
|
|
1541
|
+
// Deviation from TLC: under -continue, TLC's LiveCheck throws an InvariantViolatedException after it reports the property, which its Worker reports as unexpected.
|
|
1542
|
+
const steps = traces.getPathSteps(accepted);
|
|
1543
|
+
const properties = getViolatedProperties(
|
|
1544
|
+
liveness,
|
|
1545
|
+
steps.map((step) => step.state),
|
|
1546
|
+
steps.length - 1,
|
|
1547
|
+
);
|
|
1548
|
+
return reportViolation("property-violation", {
|
|
1549
|
+
name: properties[0],
|
|
1550
|
+
properties,
|
|
1551
|
+
...traces.toTrace(steps, accepted, { known: 0 }),
|
|
1552
|
+
});
|
|
1553
|
+
};
|
|
1554
|
+
const addReportedLiveState = (
|
|
1555
|
+
index: number,
|
|
1556
|
+
liveSuccessors: LiveSuccessor[],
|
|
1557
|
+
source: GraphState | undefined,
|
|
1558
|
+
) =>
|
|
1559
|
+
captureOutput(() => {
|
|
1560
|
+
try {
|
|
1561
|
+
return {
|
|
1562
|
+
additional: addLiveState(index, liveSuccessors, source)?.violation,
|
|
1563
|
+
isFailed: false,
|
|
1564
|
+
callStack: undefined,
|
|
1565
|
+
};
|
|
1566
|
+
} catch (error) {
|
|
1567
|
+
if (!(error instanceof TlaEvaluationError)) throw error;
|
|
1568
|
+
return {
|
|
1569
|
+
additional: undefined,
|
|
1570
|
+
isFailed: true,
|
|
1571
|
+
callStack: getLiveCallStack(index, liveSuccessors),
|
|
1572
|
+
};
|
|
1573
|
+
}
|
|
1574
|
+
});
|
|
1651
1575
|
const expandState = (index: number, liveSuccessors: LiveSuccessor[]) => {
|
|
1652
1576
|
const state = states[index];
|
|
1653
1577
|
const source = stateWriter && getGraphState(state, depths[index]);
|
|
@@ -1669,80 +1593,70 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1669
1593
|
outcome = reportNextStateOverflow(index);
|
|
1670
1594
|
return true;
|
|
1671
1595
|
}
|
|
1672
|
-
const replay = is174
|
|
1673
|
-
? captureOutput(() => replayNext(index))
|
|
1674
|
-
: replayFailedNext(index, liveSuccessors);
|
|
1675
1596
|
if (is174 && error instanceof TlaEvaluationError && !isHeadedError(error)) {
|
|
1597
|
+
const replay = captureOutput(() => replayNext(index));
|
|
1676
1598
|
outcome = createFailureResult(
|
|
1677
1599
|
new TlaEvaluationError(`${getWrappedException(error)}${error.message}`, error),
|
|
1678
1600
|
appendTraceOutput({ trace: [] }, replay.lines),
|
|
1679
|
-
{
|
|
1601
|
+
{ phase: "next", ...replay.result },
|
|
1680
1602
|
);
|
|
1681
1603
|
return true;
|
|
1682
1604
|
}
|
|
1683
|
-
const
|
|
1684
|
-
|
|
1685
|
-
|
|
1686
|
-
? getFailureMessage(
|
|
1687
|
-
isEvalException(error)
|
|
1688
|
-
? new TlaEvaluationError(`${UNEXPECTED_EVAL_EXCEPTION}${error.message}`)
|
|
1689
|
-
: error,
|
|
1690
|
-
true,
|
|
1691
|
-
)
|
|
1605
|
+
const traceError =
|
|
1606
|
+
error instanceof TlaEvaluationError && isUnfingerprintable(successor.state)
|
|
1607
|
+
? error
|
|
1692
1608
|
: undefined;
|
|
1693
|
-
|
|
1694
|
-
|
|
1695
|
-
|
|
1696
|
-
|
|
1697
|
-
|
|
1698
|
-
|
|
1699
|
-
|
|
1700
|
-
|
|
1609
|
+
const behavior = traceError
|
|
1610
|
+
? traces.getStateTrace(index, { isPrintedOnly: true })
|
|
1611
|
+
: traces.getTrace(index, successor, { isPrintedOnly: true });
|
|
1612
|
+
const traceFailure =
|
|
1613
|
+
traceError &&
|
|
1614
|
+
getTraceFailure(
|
|
1615
|
+
traceError,
|
|
1616
|
+
captureOutput(() => {
|
|
1617
|
+
try {
|
|
1618
|
+
traces.findStepAction(index, state, successor.state, true);
|
|
1619
|
+
} catch (failed) {
|
|
1620
|
+
if (!(failed instanceof TlaEvaluationError)) throw failed;
|
|
1621
|
+
}
|
|
1622
|
+
}).lines,
|
|
1623
|
+
);
|
|
1624
|
+
const replay = is174
|
|
1625
|
+
? captureOutput(() => replayNext(index))
|
|
1626
|
+
: replayFailedNext(index, liveSuccessors);
|
|
1627
|
+
outcome = createFailureResult(error, appendTraceOutput(behavior, replay.lines), {
|
|
1628
|
+
phase: "next",
|
|
1629
|
+
...replay.result,
|
|
1630
|
+
traceFailure,
|
|
1631
|
+
});
|
|
1701
1632
|
}
|
|
1702
1633
|
return outcome !== undefined;
|
|
1703
1634
|
});
|
|
1704
1635
|
current.isExpanding = false;
|
|
1705
1636
|
const result = outcome;
|
|
1706
1637
|
if (result?.violation && !is174) {
|
|
1707
|
-
const live =
|
|
1638
|
+
const live = addReportedLiveState(index, liveSuccessors, source);
|
|
1708
1639
|
return {
|
|
1709
1640
|
...result,
|
|
1710
1641
|
violation: appendTraceOutput(result.violation, live.lines),
|
|
1711
|
-
|
|
1642
|
+
// TLC adds the state to the behavior graph before it reports the coverage.
|
|
1643
|
+
coverage: getCoverage(),
|
|
1644
|
+
...(live.result.additional && { additionalViolation: live.result.additional }),
|
|
1645
|
+
...(live.result.callStack && { liveCallStack: live.result.callStack }),
|
|
1712
1646
|
};
|
|
1713
1647
|
}
|
|
1714
1648
|
if (result) return result;
|
|
1715
|
-
const addLiveState = () => {
|
|
1716
|
-
if (liveness && source && (is174 || options.dump?.stuttering)) {
|
|
1717
|
-
stateWriter?.writeStuttering(source);
|
|
1718
|
-
}
|
|
1719
|
-
const accepted = liveness?.addState(index, state, liveSuccessors);
|
|
1720
|
-
if (!liveness || !accepted) return undefined;
|
|
1721
|
-
const steps = getPathSteps(accepted);
|
|
1722
|
-
const properties = getViolatedProperties(
|
|
1723
|
-
liveness,
|
|
1724
|
-
steps.map((step) => step.state),
|
|
1725
|
-
steps.length - 1,
|
|
1726
|
-
);
|
|
1727
|
-
return reportViolation("property-violation", {
|
|
1728
|
-
name: properties[0],
|
|
1729
|
-
properties,
|
|
1730
|
-
...toTrace(steps, accepted, { known: 0 }),
|
|
1731
|
-
});
|
|
1732
|
-
};
|
|
1733
1649
|
if (successorCount === 0 && config.checkDeadlock) {
|
|
1734
|
-
const deadlock = reportViolation("deadlock", {
|
|
1735
|
-
|
|
1736
|
-
|
|
1737
|
-
return { additional: addLiveState()?.violation };
|
|
1738
|
-
} catch (error) {
|
|
1739
|
-
if (!(error instanceof TlaEvaluationError)) throw error;
|
|
1740
|
-
return { isFailed: true, callStack: getLiveCallStack(index, liveSuccessors) };
|
|
1741
|
-
}
|
|
1650
|
+
const deadlock = reportViolation("deadlock", {
|
|
1651
|
+
name: "deadlock",
|
|
1652
|
+
...traces.getStateTrace(index),
|
|
1742
1653
|
});
|
|
1743
|
-
const
|
|
1744
|
-
|
|
1745
|
-
|
|
1654
|
+
const live = addReportedLiveState(index, liveSuccessors, source);
|
|
1655
|
+
const reported = {
|
|
1656
|
+
...deadlock,
|
|
1657
|
+
violation: deadlock.violation && appendTraceOutput(deadlock.violation, live.lines),
|
|
1658
|
+
coverage: getCoverage(),
|
|
1659
|
+
};
|
|
1746
1660
|
const counted = withOutDegrees(
|
|
1747
1661
|
reported,
|
|
1748
1662
|
live.result.isFailed ? getFailureOutDegrees() : getPartialOutDegrees(),
|
|
@@ -1752,26 +1666,24 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1752
1666
|
return live.result.callStack ? { ...counted, liveCallStack: live.result.callStack } : counted;
|
|
1753
1667
|
}
|
|
1754
1668
|
try {
|
|
1755
|
-
return addLiveState();
|
|
1669
|
+
return addLiveState(index, liveSuccessors, source);
|
|
1756
1670
|
} catch (error) {
|
|
1757
1671
|
if (is174 && error instanceof TlaEvaluationError) {
|
|
1758
|
-
const unexpected = new TlaEvaluationError(
|
|
1759
|
-
`${isEvalException(error) ? UNEXPECTED_EVAL_EXCEPTION : UNEXPECTED_EXCEPTION}${error.message}`,
|
|
1760
|
-
);
|
|
1761
1672
|
return createFailureResult(
|
|
1762
|
-
setExitCode(
|
|
1673
|
+
setExitCode(toUnexpectedError(error), EXIT_STATUS.error),
|
|
1763
1674
|
{ trace: [] },
|
|
1764
1675
|
{ outDegrees: getFailureOutDegrees() },
|
|
1765
1676
|
);
|
|
1766
1677
|
}
|
|
1767
|
-
const replay = getReplayFailure((tracing) =>
|
|
1678
|
+
const replay = getReplayFailure(environment, (tracing) =>
|
|
1768
1679
|
liveness?.addState(index, state, liveSuccessors, tracing),
|
|
1769
1680
|
);
|
|
1770
|
-
|
|
1681
|
+
const behavior = traces.getStateTrace(index, { isPrintedOnly: true });
|
|
1682
|
+
const replayed = captureOutput(() => replayNext(index));
|
|
1683
|
+
return createFailureResult(error, appendTraceOutput(behavior, replayed.lines), {
|
|
1771
1684
|
outDegrees: getFailureOutDegrees(),
|
|
1772
1685
|
callStack: replay?.callStack.length ? replay.callStack : undefined,
|
|
1773
|
-
|
|
1774
|
-
isCallStackFirst: true,
|
|
1686
|
+
phase: "liveness",
|
|
1775
1687
|
});
|
|
1776
1688
|
}
|
|
1777
1689
|
};
|
|
@@ -1792,11 +1704,21 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1792
1704
|
text: `The stuttering counterexample above may be caused by the absence of a fairness constraint in the behavior specification ${name} defined at ${formatRange(range)}. To rule out such counterexamples, conjoin a suitable fairness constraint to ${name} ${book}`,
|
|
1793
1705
|
};
|
|
1794
1706
|
};
|
|
1707
|
+
const toLivenessFailure = (error: TlaEvaluationError) =>
|
|
1708
|
+
setExitCode(toUnexpectedError(error), EXIT_STATUS.abort);
|
|
1709
|
+
const getLassoSteps = (path: number[]) => {
|
|
1710
|
+
try {
|
|
1711
|
+
return traces.getPathSteps(path);
|
|
1712
|
+
} catch (error) {
|
|
1713
|
+
if (!(error instanceof TlaEvaluationError)) throw error;
|
|
1714
|
+
throw toLivenessFailure(error);
|
|
1715
|
+
}
|
|
1716
|
+
};
|
|
1795
1717
|
const reportLasso = (checker: LivenessChecker, lasso: Lasso) => {
|
|
1796
1718
|
const path = [...lasso.prefix, ...lasso.cycle];
|
|
1797
1719
|
const loopStart = lasso.prefix.length;
|
|
1798
|
-
const steps =
|
|
1799
|
-
const trace = toTrace(steps, path, { loopStart, known: 0 }).trace;
|
|
1720
|
+
const steps = getLassoSteps(path);
|
|
1721
|
+
const trace = traces.toTrace(steps, path, { loopStart, known: 0 }).trace;
|
|
1800
1722
|
const properties = getViolatedProperties(
|
|
1801
1723
|
checker,
|
|
1802
1724
|
steps.map((step) => step.state),
|
|
@@ -1805,11 +1727,28 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1805
1727
|
const cycleStart = path[loopStart];
|
|
1806
1728
|
const cycleEnd = path[path.length - 1];
|
|
1807
1729
|
const lastState = steps[steps.length - 1].state;
|
|
1808
|
-
const
|
|
1809
|
-
|
|
1810
|
-
|
|
1811
|
-
|
|
1812
|
-
const
|
|
1730
|
+
const isStuttering = cycleStart === cycleEnd;
|
|
1731
|
+
const loop = isStuttering
|
|
1732
|
+
? { result: undefined, lines: [] }
|
|
1733
|
+
: captureOutput(() => traces.findStepAction(cycleEnd, lastState, states[cycleStart], false));
|
|
1734
|
+
const back =
|
|
1735
|
+
isStuttering || loop.result
|
|
1736
|
+
? undefined
|
|
1737
|
+
: traces.findSuccessorWithFingerprint(lastState, cycleEnd, cycleStart);
|
|
1738
|
+
if (!isStuttering && !loop.result && !back) {
|
|
1739
|
+
options.onProgress?.({
|
|
1740
|
+
kind: "violation",
|
|
1741
|
+
status: "property-violation",
|
|
1742
|
+
violation: {
|
|
1743
|
+
name: properties[0],
|
|
1744
|
+
properties,
|
|
1745
|
+
trace,
|
|
1746
|
+
traceOutput: loop.lines,
|
|
1747
|
+
loopStart: undefined,
|
|
1748
|
+
},
|
|
1749
|
+
});
|
|
1750
|
+
throw toLivenessFailure(new TlaEvaluationError(NEXT_RECOVERY_FAILURE));
|
|
1751
|
+
}
|
|
1813
1752
|
return reportViolation(
|
|
1814
1753
|
"liveness-violation",
|
|
1815
1754
|
{
|
|
@@ -1819,62 +1758,171 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1819
1758
|
traceOutput: loop.lines,
|
|
1820
1759
|
loopStart,
|
|
1821
1760
|
loopLabel: loop.result && getActionLabel(loop.result, options.version),
|
|
1822
|
-
warning:
|
|
1761
|
+
warning: isStuttering && lasso.isCycleConstrained ? getStutteringWarning() : undefined,
|
|
1823
1762
|
},
|
|
1763
|
+
getStepState,
|
|
1824
1764
|
() =>
|
|
1825
|
-
|
|
1765
|
+
isStuttering
|
|
1826
1766
|
? getStepAction(trace[trace.length - 1])
|
|
1827
1767
|
: loop.result
|
|
1828
1768
|
? toActionValue(loop.result)
|
|
1829
|
-
: createActionRecord(
|
|
1769
|
+
: createActionRecord(back?.action),
|
|
1830
1770
|
);
|
|
1831
1771
|
};
|
|
1832
1772
|
const isPeriodic = liveness !== undefined && (options.livenessCheck ?? "default") === "default";
|
|
1833
1773
|
const startedAt = performance.now();
|
|
1834
1774
|
const periodic = {
|
|
1835
1775
|
at: startedAt + PERIODIC_START,
|
|
1836
|
-
|
|
1776
|
+
checkedCounts: liveness?.getStateCounts().map(() => 1) ?? [],
|
|
1837
1777
|
time: 0,
|
|
1838
1778
|
coverageCount: Math.trunc(options.coverage ?? 0),
|
|
1839
1779
|
};
|
|
1840
|
-
const
|
|
1780
|
+
const getGraphStates = (checker: LivenessChecker) =>
|
|
1781
|
+
checker.getStateCounts().reduce((sum, count) => sum + count, 0);
|
|
1782
|
+
const findPeriodicViolation = (checker: LivenessChecker) => {
|
|
1841
1783
|
const now = performance.now();
|
|
1842
|
-
const
|
|
1784
|
+
const counts = checker.getStateCounts();
|
|
1785
|
+
const isGrown = counts.some(
|
|
1786
|
+
(count, branch) =>
|
|
1787
|
+
(count - periodic.checkedCounts[branch]) / periodic.checkedCounts[branch] > LIVENESS_GROWTH,
|
|
1788
|
+
);
|
|
1843
1789
|
if (!isGrown || periodic.time > (now - startedAt) * LIVENESS_RATIO) return undefined;
|
|
1844
|
-
periodic.
|
|
1845
|
-
if (!liveness) return undefined;
|
|
1790
|
+
periodic.checkedCounts = counts;
|
|
1846
1791
|
options.onProgress?.({
|
|
1847
1792
|
kind: "liveness-started",
|
|
1848
|
-
branches:
|
|
1793
|
+
branches: checker.branches,
|
|
1849
1794
|
isComplete: false,
|
|
1850
|
-
states:
|
|
1795
|
+
states: getGraphStates(checker),
|
|
1851
1796
|
statistics: createResult("success"),
|
|
1852
1797
|
});
|
|
1853
|
-
const lasso =
|
|
1798
|
+
const lasso = checker.findViolation();
|
|
1854
1799
|
if (!lasso) options.onProgress?.({ kind: "liveness-finished" });
|
|
1855
1800
|
periodic.time += performance.now() - now;
|
|
1856
1801
|
return lasso;
|
|
1857
1802
|
};
|
|
1858
|
-
|
|
1803
|
+
const adoptTypedSearch = (searched: TypedResult) => {
|
|
1804
|
+
runtime.generatedStates = searched.generatedStates;
|
|
1805
|
+
runtime.distinctStates = searched.distinctStates;
|
|
1806
|
+
runtime.queueSize = searched.queuedStates;
|
|
1807
|
+
runtime.diameter = searched.depth;
|
|
1808
|
+
searchDepth = searched.depth;
|
|
1809
|
+
outDegrees.splice(0, outDegrees.length, ...searched.outDegrees);
|
|
1810
|
+
newStateCount = 0;
|
|
1811
|
+
};
|
|
1812
|
+
// The tier found a state without successors, or a successor that violates an invariant or an
|
|
1813
|
+
// action property. The interpreter rebuilds the tier's path to it and reports it, as it would after
|
|
1814
|
+
// its own search.
|
|
1815
|
+
const path = typed?.deadlock ?? typed?.violation;
|
|
1816
|
+
const initialIndex = path ? states.findIndex((state) => path.isPathState(0, state)) : -1;
|
|
1817
|
+
if (typed && path && initialIndex !== -1) {
|
|
1818
|
+
const steps: { successor: Successor; action: SpecAction | undefined }[] = [];
|
|
1819
|
+
const getLastState = () => steps.at(-1)?.successor.state ?? states[initialIndex];
|
|
1820
|
+
for (let position = 1; position === steps.length + 1 && position < path.length; position++) {
|
|
1821
|
+
// The interpreter expands only the states it stores, which it has canonicalized.
|
|
1822
|
+
canonicalizeState(getLastState());
|
|
1823
|
+
forEachActionSuccessor(getLastState(), undefined, (successor, action) => {
|
|
1824
|
+
if (!path.isPathState(position, successor.state)) return false;
|
|
1825
|
+
steps.push({ successor, action });
|
|
1826
|
+
return true;
|
|
1827
|
+
});
|
|
1828
|
+
}
|
|
1829
|
+
const isRebuilt = steps.length === path.length - 1;
|
|
1830
|
+
const violating = typed.violation && isRebuilt ? steps.pop() : undefined;
|
|
1831
|
+
if (violating && isCanonicalizedFirst) canonicalizeState(violating.successor.state);
|
|
1832
|
+
const violatedInvariant =
|
|
1833
|
+
violating && search.findViolatedInvariant(violating.successor.state, getLastState());
|
|
1834
|
+
const violatedProperty =
|
|
1835
|
+
violating &&
|
|
1836
|
+
!violatedInvariant &&
|
|
1837
|
+
search.findViolatedActionProperty(getLastState(), violating.successor.state);
|
|
1838
|
+
const violated = violatedInvariant ?? violatedProperty;
|
|
1839
|
+
const isDeadlocked =
|
|
1840
|
+
typed.deadlock !== undefined &&
|
|
1841
|
+
isRebuilt &&
|
|
1842
|
+
forEachActionSuccessor(getLastState(), undefined, () => true) === 0;
|
|
1843
|
+
if (isDeadlocked || violated) {
|
|
1844
|
+
const parent = { index: initialIndex };
|
|
1845
|
+
for (const step of steps) {
|
|
1846
|
+
visitSuccessor(parent.index, step.successor, [], undefined, step.action);
|
|
1847
|
+
parent.index = states.length - 1;
|
|
1848
|
+
}
|
|
1849
|
+
adoptTypedSearch(typed);
|
|
1850
|
+
Object.assign(current, { index: parent.index, candidate: undefined, isExpanding: true });
|
|
1851
|
+
if (violating && violated) {
|
|
1852
|
+
lookUpSuccessor(states[parent.index], violating.successor);
|
|
1853
|
+
current.candidate = violating.successor.state;
|
|
1854
|
+
current.candidateLevel = depths[parent.index] + 1;
|
|
1855
|
+
return withOutDegrees(
|
|
1856
|
+
reportViolation(violatedInvariant ? "invariant-violation" : "liveness-violation", {
|
|
1857
|
+
name: violated.name,
|
|
1858
|
+
...traces.getTrace(parent.index, violating.successor),
|
|
1859
|
+
}),
|
|
1860
|
+
);
|
|
1861
|
+
}
|
|
1862
|
+
const result = expandState(parent.index, []);
|
|
1863
|
+
if (result) return result;
|
|
1864
|
+
}
|
|
1865
|
+
}
|
|
1866
|
+
// The tier found a behavior that violates a temporal property after its whole search. The
|
|
1867
|
+
// interpreter stores the paths to the lasso's states and reports it, as it would after its own.
|
|
1868
|
+
const lassoSteps = new Map<number, { successor: Successor; action: SpecAction | undefined }>();
|
|
1869
|
+
for (const entry of typed?.lasso?.states ?? []) {
|
|
1870
|
+
const initial = entry.parent === -1 ? states.find(entry.isState) : undefined;
|
|
1871
|
+
if (initial) {
|
|
1872
|
+
lassoSteps.set(entry.index, {
|
|
1873
|
+
successor: { state: initial, action: undefined },
|
|
1874
|
+
action: undefined,
|
|
1875
|
+
});
|
|
1876
|
+
}
|
|
1877
|
+
const parent = lassoSteps.get(entry.parent)?.successor.state;
|
|
1878
|
+
if (!parent) continue;
|
|
1879
|
+
// The interpreter expands only the states it stores, which it has canonicalized.
|
|
1880
|
+
canonicalizeState(parent);
|
|
1881
|
+
forEachActionSuccessor(parent, undefined, (successor, action) => {
|
|
1882
|
+
if (!entry.isState(successor.state)) return false;
|
|
1883
|
+
lassoSteps.set(entry.index, { successor, action });
|
|
1884
|
+
return true;
|
|
1885
|
+
});
|
|
1886
|
+
}
|
|
1887
|
+
const lassoIndexes = new Map<number, number>();
|
|
1888
|
+
const typedLasso =
|
|
1889
|
+
typed?.lasso && lassoSteps.size === typed.lasso.states.length ? typed.lasso : undefined;
|
|
1890
|
+
typedLasso?.states.forEach((entry) => {
|
|
1891
|
+
const step = lassoSteps.get(entry.index);
|
|
1892
|
+
const parent = lassoIndexes.get(entry.parent);
|
|
1893
|
+
if (step && parent !== undefined)
|
|
1894
|
+
visitSuccessor(parent, step.successor, [], undefined, step.action);
|
|
1895
|
+
lassoIndexes.set(
|
|
1896
|
+
entry.index,
|
|
1897
|
+
parent === undefined ? states.findIndex(entry.isState) : states.length - 1,
|
|
1898
|
+
);
|
|
1899
|
+
});
|
|
1900
|
+
if (typed && typedLasso) adoptTypedSearch(typed);
|
|
1901
|
+
for (
|
|
1902
|
+
let index = typedLasso ? states.length : 0;
|
|
1903
|
+
index < states.length && !runtime.isStopped;
|
|
1904
|
+
index++
|
|
1905
|
+
) {
|
|
1859
1906
|
current.index = index;
|
|
1860
1907
|
current.candidate = undefined;
|
|
1861
1908
|
runtime.queueSize = states.length - index - 1;
|
|
1862
1909
|
current.isExpanding = true;
|
|
1863
1910
|
const liveSuccessors: LiveSuccessor[] = [];
|
|
1911
|
+
const generated = runtime.generatedStates;
|
|
1864
1912
|
try {
|
|
1865
1913
|
outcome = expandState(index, liveSuccessors);
|
|
1866
1914
|
} catch (error) {
|
|
1867
1915
|
outcome =
|
|
1868
1916
|
error instanceof TlaIncompleteSuccessorError
|
|
1869
|
-
? reportIncompleteSuccessor(index, error)
|
|
1870
|
-
: reportNextStateFailure(error, index, liveSuccessors);
|
|
1917
|
+
? reportIncompleteSuccessor(index, error, liveSuccessors)
|
|
1918
|
+
: reportNextStateFailure(error, index, liveSuccessors, generated);
|
|
1871
1919
|
}
|
|
1872
1920
|
if (outcome) return outcome;
|
|
1873
1921
|
outDegrees[getOutDegreeBucket()]++;
|
|
1874
1922
|
newStateCount = 0;
|
|
1875
1923
|
if ((isPeriodic || options.onProgress) && performance.now() >= periodic.at) {
|
|
1876
1924
|
periodic.at = performance.now() + PROGRESS_INTERVAL;
|
|
1877
|
-
const lasso = isPeriodic ? findPeriodicViolation(
|
|
1925
|
+
const lasso = isPeriodic && liveness ? findPeriodicViolation(liveness) : undefined;
|
|
1878
1926
|
if (liveness && lasso) return reportLasso(liveness, lasso);
|
|
1879
1927
|
const isCoverageDue = options.coverage !== undefined && periodic.coverageCount === 0;
|
|
1880
1928
|
periodic.coverageCount = isCoverageDue
|
|
@@ -1896,11 +1944,21 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1896
1944
|
kind: "liveness-started",
|
|
1897
1945
|
branches: finalLiveness.branches,
|
|
1898
1946
|
isComplete: true,
|
|
1899
|
-
states:
|
|
1947
|
+
states: typedLasso
|
|
1948
|
+
? finalLiveness.branches * runtime.distinctStates
|
|
1949
|
+
: getGraphStates(finalLiveness),
|
|
1900
1950
|
statistics: createResult("success"),
|
|
1901
1951
|
});
|
|
1902
1952
|
}
|
|
1903
|
-
const
|
|
1953
|
+
const getLassoIndexes = (indexes: number[]) =>
|
|
1954
|
+
indexes.map((index) => lassoIndexes.get(index) ?? -1);
|
|
1955
|
+
const lasso = typedLasso
|
|
1956
|
+
? {
|
|
1957
|
+
prefix: getLassoIndexes(typedLasso.prefix),
|
|
1958
|
+
cycle: getLassoIndexes(typedLasso.cycle),
|
|
1959
|
+
isCycleConstrained: typedLasso.isCycleConstrained,
|
|
1960
|
+
}
|
|
1961
|
+
: finalLiveness?.findViolation();
|
|
1904
1962
|
if (finalLiveness && lasso) return reportLasso(finalLiveness, lasso);
|
|
1905
1963
|
|
|
1906
1964
|
if (finalLiveness) options.onProgress?.({ kind: "liveness-finished" });
|