tla-ts 0.0.9 → 0.0.10-dev.28c823e4b
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 +29 -1
- package/dist/compile.cjs +23 -0
- package/dist/compile.js +23 -0
- package/dist/deciders.cjs +28 -28
- package/dist/deciders.js +43 -43
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +106 -10
- package/dist/index.d.ts +106 -10
- 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 +116 -36
- package/dist/prove.js +116 -36
- package/dist/run.cjs +143 -31
- package/dist/run.js +143 -31
- package/dist/tlapm.cjs +2 -2
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +129 -104
- package/dist/transfer.js +129 -104
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +3 -1
- package/src/ast.ts +4 -23
- package/src/bags.ts +99 -102
- package/src/builtins.ts +40 -78
- package/src/bundled-modules.ts +1 -8
- package/src/check.ts +599 -388
- package/src/cli/options.ts +11 -6
- package/src/cli/run.ts +0 -2
- package/src/cli/runtime-invariants.ts +136 -0
- package/src/cli/shared.ts +18 -11
- package/src/cli/tlapm.ts +0 -12
- package/src/cli/tlc-arguments.ts +640 -0
- package/src/cli/tlc-usage.ts +361 -0
- package/src/cli/tlc.ts +538 -220
- package/src/cli/typescript.ts +23 -0
- package/src/cli/xml-exporter.ts +4 -16
- package/src/cli.ts +0 -1
- package/src/codegen.ts +191 -64
- package/src/config.ts +140 -109
- package/src/coverage.ts +837 -0
- package/src/dependencies.ts +6 -40
- package/src/dfid.ts +618 -0
- package/src/environment.ts +240 -118
- package/src/errors.ts +70 -55
- package/src/evaluate.ts +596 -339
- package/src/exit-codes.ts +37 -3
- package/src/fingerprints.ts +10 -10
- package/src/index.ts +3 -0
- package/src/instances.ts +79 -11
- package/src/java-overrides.ts +4 -19
- package/src/json-reader.ts +455 -0
- package/src/json.ts +255 -139
- package/src/levels.ts +8 -17
- package/src/lexer.ts +80 -100
- package/src/liveness-checker.ts +82 -119
- package/src/liveness.ts +112 -64
- package/src/obligations/action.ts +4 -28
- package/src/obligations/anonymize.ts +84 -80
- package/src/obligations/equality.ts +1 -1
- package/src/obligations/expression.ts +2 -19
- package/src/obligations/format.ts +1 -9
- package/src/obligations/generate.ts +1 -11
- package/src/obligations/index.ts +0 -11
- package/src/obligations/levels.ts +4 -8
- package/src/obligations/module.ts +1 -15
- package/src/obligations/normalize.ts +5 -24
- package/src/obligations/operators.ts +1 -2
- package/src/obligations/pragma.ts +1 -10
- package/src/obligations/printer.ts +47 -46
- package/src/obligations/proof.ts +1 -5
- package/src/obligations/regroup.ts +1 -4
- package/src/obligations/simplify.ts +3 -14
- package/src/obligations/source.ts +1 -21
- package/src/obligations/subexpression.ts +5 -11
- package/src/obligations/substitution.ts +1 -3
- package/src/obligations/temporal.ts +8 -14
- package/src/obligations/tuples.ts +3 -9
- package/src/parallel-worker.ts +29 -39
- package/src/parallel.ts +53 -44
- package/src/parser.ts +565 -282
- package/src/pcal/ast.ts +53 -86
- package/src/pcal/parse.ts +144 -219
- package/src/pcal/tokenize.ts +91 -131
- package/src/pcal/translate.ts +83 -130
- package/src/pcal/validate.ts +48 -68
- package/src/pretty-print.ts +7 -8
- package/src/prover/decide-pool.ts +5 -10
- package/src/prover/deciders.ts +0 -4
- package/src/prover/first-order.ts +0 -11
- package/src/prover/isabelle/decide.ts +0 -6
- package/src/prover/isabelle/encode.ts +11 -23
- package/src/prover/isabelle/isar/inner-syntax.ts +108 -114
- package/src/prover/isabelle/isar/method.ts +25 -38
- package/src/prover/isabelle/isar/proof.ts +1 -10
- package/src/prover/isabelle/isar/statement.ts +1 -6
- package/src/prover/isabelle/isar/theory.ts +15 -26
- package/src/prover/isabelle/isar/type-check.ts +11 -25
- package/src/prover/isabelle/provers/blast/blast.ts +10 -41
- package/src/prover/isabelle/provers/blast/branch.ts +1 -32
- package/src/prover/isabelle/provers/blast/prove.ts +1 -35
- package/src/prover/isabelle/provers/blast/rules.ts +6 -44
- package/src/prover/isabelle/provers/blast/state.ts +2 -28
- package/src/prover/isabelle/provers/blast/term.ts +9 -36
- package/src/prover/isabelle/provers/clasimp.ts +1 -13
- package/src/prover/isabelle/provers/classical.ts +14 -42
- package/src/prover/isabelle/provers/hypsubst.ts +11 -25
- package/src/prover/isabelle/pure/bicompose.ts +16 -13
- package/src/prover/isabelle/pure/consts.ts +1 -7
- package/src/prover/isabelle/pure/conv.ts +1 -9
- package/src/prover/isabelle/pure/drule.ts +24 -40
- package/src/prover/isabelle/pure/envir.ts +3 -52
- package/src/prover/isabelle/pure/goal.ts +1 -7
- package/src/prover/isabelle/pure/interrupt.ts +0 -5
- package/src/prover/isabelle/pure/list.ts +0 -3
- package/src/prover/isabelle/pure/logic.ts +1 -14
- package/src/prover/isabelle/pure/name.ts +2 -9
- package/src/prover/isabelle/pure/net.ts +3 -59
- package/src/prover/isabelle/pure/object-logic.ts +3 -10
- package/src/prover/isabelle/pure/pattern.ts +2 -19
- package/src/prover/isabelle/pure/raw-simplifier.ts +13 -49
- package/src/prover/isabelle/pure/rewriter.ts +26 -58
- package/src/prover/isabelle/pure/search.ts +3 -10
- package/src/prover/isabelle/pure/seq.ts +1 -10
- package/src/prover/isabelle/pure/simplifier.ts +4 -12
- package/src/prover/isabelle/pure/table.ts +1 -31
- package/src/prover/isabelle/pure/tactic.ts +12 -22
- package/src/prover/isabelle/pure/tactical.ts +6 -12
- package/src/prover/isabelle/pure/term-ord.ts +2 -6
- package/src/prover/isabelle/pure/term.ts +2 -43
- package/src/prover/isabelle/pure/thm.ts +13 -36
- package/src/prover/isabelle/pure/type.ts +2 -15
- package/src/prover/isabelle/pure/unify.ts +20 -30
- package/src/prover/isabelle/pure/variable.ts +3 -7
- package/src/prover/isabelle/tla/classical-setup.ts +9 -19
- package/src/prover/isabelle/tla/context.ts +8 -16
- package/src/prover/isabelle/tla/logic.ts +4 -11
- package/src/prover/isabelle/tla/simpdata.ts +46 -34
- package/src/prover/isabelle/tools/intuitionistic.ts +1 -10
- package/src/prover/ocaml.ts +0 -6
- package/src/prover/prep/action.ts +4 -36
- package/src/prover/prep/enabled-axioms.ts +12 -19
- package/src/prover/prep/fingerprint.ts +0 -16
- package/src/prover/prep/level-comparison.ts +8 -12
- package/src/prover/prep/md5.ts +0 -2
- package/src/prover/prep/methods.ts +9 -36
- package/src/prover/prep/normalize.ts +4 -28
- package/src/prover/prove-worker.ts +0 -2
- package/src/prover/prove.ts +0 -36
- package/src/prover/ptl/decide.ts +7 -12
- package/src/prover/ptl/encode.ts +14 -36
- package/src/prover/ptl/sat.ts +24 -32
- package/src/prover/ptl/tableau.ts +12 -26
- package/src/prover/smt/axioms.ts +0 -7
- package/src/prover/smt/context.ts +19 -26
- package/src/prover/smt/data.ts +51 -54
- package/src/prover/smt/encode.ts +14 -35
- package/src/prover/smt/extensionality.ts +0 -10
- package/src/prover/smt/flatten.ts +3 -22
- package/src/prover/smt/format.ts +5 -10
- package/src/prover/smt/instances.ts +0 -10
- package/src/prover/smt/rewrite.ts +66 -101
- package/src/prover/smt/solver/act-cache.ts +0 -15
- package/src/prover/smt/solver/arith-rewriter.ts +3 -48
- package/src/prover/smt/solver/array.ts +1 -3
- package/src/prover/smt/solver/asserted-formulas.ts +1 -43
- package/src/prover/smt/solver/ast-lt.ts +1 -11
- package/src/prover/smt/solver/ast-util.ts +1 -6
- package/src/prover/smt/solver/ast.ts +1 -143
- package/src/prover/smt/solver/auf-solver.ts +6 -39
- package/src/prover/smt/solver/case-split-queue.ts +1 -9
- package/src/prover/smt/solver/cg-table.ts +1 -18
- package/src/prover/smt/solver/clause.ts +1 -27
- package/src/prover/smt/solver/conflict-resolution.ts +0 -9
- package/src/prover/smt/solver/context.ts +4 -61
- package/src/prover/smt/solver/ctx-simplify.ts +14 -41
- package/src/prover/smt/solver/der.ts +2 -21
- package/src/prover/smt/solver/dyn-ack.ts +1 -11
- package/src/prover/smt/solver/e-matching.ts +3 -34
- package/src/prover/smt/solver/enode.ts +1 -21
- package/src/prover/smt/solver/expr-ref.ts +1 -5
- package/src/prover/smt/solver/expr-safe-replace.ts +0 -5
- package/src/prover/smt/solver/fingerprints.ts +1 -12
- package/src/prover/smt/solver/flat-literals.ts +1 -9
- package/src/prover/smt/solver/goal.ts +2 -14
- package/src/prover/smt/solver/hash.ts +0 -8
- package/src/prover/smt/solver/hashtable.ts +1 -12
- package/src/prover/smt/solver/internalizer.ts +6 -98
- package/src/prover/smt/solver/lbool.ts +1 -2
- package/src/prover/smt/solver/literal.ts +0 -3
- package/src/prover/smt/solver/lp/bound-propagator.ts +8 -26
- package/src/prover/smt/solver/lp/constraints.ts +2 -8
- package/src/prover/smt/solver/lp/containers.ts +12 -30
- package/src/prover/smt/solver/lp/core-solver.ts +10 -31
- package/src/prover/smt/solver/lp/cross-nested.ts +6 -20
- package/src/prover/smt/solver/lp/dep-intervals.ts +7 -22
- package/src/prover/smt/solver/lp/dependency.ts +1 -4
- package/src/prover/smt/solver/lp/dioph-eq.ts +12 -98
- package/src/prover/smt/solver/lp/explanation.ts +1 -6
- package/src/prover/smt/solver/lp/gomory.ts +9 -22
- package/src/prover/smt/solver/lp/hnf-cutter.ts +17 -23
- package/src/prover/smt/solver/lp/hnf.ts +11 -26
- package/src/prover/smt/solver/lp/int-cube.ts +15 -36
- package/src/prover/smt/solver/lp/int-solver.ts +4 -34
- package/src/prover/smt/solver/lp/lar-solver.ts +32 -81
- package/src/prover/smt/solver/lp/lar-term.ts +1 -5
- package/src/prover/smt/solver/lp/lp-settings.ts +1 -14
- package/src/prover/smt/solver/lp/maximize-term.ts +20 -45
- package/src/prover/smt/solver/lp/nex-creator.ts +5 -28
- package/src/prover/smt/solver/lp/nex.ts +1 -6
- package/src/prover/smt/solver/lp/nla-backoff.ts +1 -4
- package/src/prover/smt/solver/lp/nla-basics.ts +5 -30
- package/src/prover/smt/solver/lp/nla-core.ts +35 -130
- package/src/prover/smt/solver/lp/nla-divisions.ts +32 -42
- package/src/prover/smt/solver/lp/nla-emonics.ts +4 -21
- package/src/prover/smt/solver/lp/nla-factorization.ts +1 -4
- package/src/prover/smt/solver/lp/nla-grobner.ts +15 -69
- package/src/prover/smt/solver/lp/nla-horner.ts +3 -11
- package/src/prover/smt/solver/lp/nla-intervals.ts +2 -12
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +16 -41
- package/src/prover/smt/solver/lp/nla-monotone.ts +2 -6
- package/src/prover/smt/solver/lp/nla-order.ts +2 -13
- package/src/prover/smt/solver/lp/nla-patcher.ts +4 -7
- package/src/prover/smt/solver/lp/nla-tangents.ts +1 -9
- package/src/prover/smt/solver/lp/nla-throttle.ts +1 -6
- package/src/prover/smt/solver/lp/nla-types.ts +1 -11
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -25
- package/src/prover/smt/solver/lp/nra-solver.ts +5 -52
- package/src/prover/smt/solver/lp/numeric-pair.ts +1 -4
- package/src/prover/smt/solver/lp/pdd-interval.ts +1 -3
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +2 -14
- package/src/prover/smt/solver/lp/pdd-solver.ts +4 -33
- package/src/prover/smt/solver/lp/pdd.ts +7 -70
- package/src/prover/smt/solver/lp/random-updater.ts +1 -8
- package/src/prover/smt/solver/lp/static-matrix.ts +9 -19
- package/src/prover/smt/solver/lp/union-find.ts +1 -6
- package/src/prover/smt/solver/mam-compiler.ts +14 -56
- package/src/prover/smt/solver/mam-interpreter.ts +1 -21
- package/src/prover/smt/solver/maximize-ac-sharing.ts +2 -17
- package/src/prover/smt/solver/model-checker.ts +2 -36
- package/src/prover/smt/solver/model-evaluator.ts +3 -29
- package/src/prover/smt/solver/model-finder.ts +3 -15
- package/src/prover/smt/solver/model-generator.ts +1 -12
- package/src/prover/smt/solver/model-macro-solver.ts +12 -69
- package/src/prover/smt/solver/nlsat/algebraic.ts +55 -151
- package/src/prover/smt/solver/nlsat/atoms.ts +5 -19
- package/src/prover/smt/solver/nlsat/evaluator.ts +17 -22
- package/src/prover/smt/solver/nlsat/explain.ts +3 -47
- package/src/prover/smt/solver/nlsat/interval-set.ts +9 -50
- package/src/prover/smt/solver/nlsat/levelwise.ts +48 -129
- package/src/prover/smt/solver/nlsat/mpbq.ts +3 -14
- package/src/prover/smt/solver/nlsat/polynomial.ts +17 -156
- package/src/prover/smt/solver/nlsat/solver.ts +7 -67
- package/src/prover/smt/solver/nlsat/types.ts +1 -8
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +1 -44
- package/src/prover/smt/solver/nlsat/upolynomial.ts +11 -92
- package/src/prover/smt/solver/nnf.ts +3 -38
- package/src/prover/smt/solver/pattern-inference.ts +2 -15
- package/src/prover/smt/solver/poly-rewriter.ts +3 -23
- package/src/prover/smt/solver/propagate-values.ts +1 -10
- package/src/prover/smt/solver/proto-model.ts +3 -48
- package/src/prover/smt/solver/pull-quant.ts +1 -12
- package/src/prover/smt/solver/qe-lite-der.ts +1 -29
- package/src/prover/smt/solver/qe-lite-fm.ts +2 -25
- package/src/prover/smt/solver/qe-lite.ts +3 -33
- package/src/prover/smt/solver/qi-queue.ts +1 -16
- package/src/prover/smt/solver/quant-tactics.ts +5 -22
- package/src/prover/smt/solver/quantifier-analyzer.ts +17 -37
- package/src/prover/smt/solver/quantifier-manager.ts +1 -8
- package/src/prover/smt/solver/random-gen.ts +1 -2
- package/src/prover/smt/solver/rational.ts +1 -8
- package/src/prover/smt/solver/ref-vector.ts +1 -6
- package/src/prover/smt/solver/relevancy.ts +2 -15
- package/src/prover/smt/solver/rewriter-tpl.ts +3 -147
- package/src/prover/smt/solver/rewriter.ts +3 -85
- package/src/prover/smt/solver/rlimit.ts +2 -20
- package/src/prover/smt/solver/smtlib-parser.ts +2 -37
- package/src/prover/smt/solver/solver.ts +23 -34
- package/src/prover/smt/solver/sort.ts +1 -5
- package/src/prover/smt/solver/sticky-generations.ts +0 -5
- package/src/prover/smt/solver/theory-lra-axioms.ts +3 -24
- package/src/prover/smt/solver/theory-lra-bounds.ts +0 -5
- package/src/prover/smt/solver/theory-lra-final-check.ts +4 -22
- package/src/prover/smt/solver/theory-lra-internalize.ts +1 -27
- package/src/prover/smt/solver/theory-lra-model.ts +4 -19
- package/src/prover/smt/solver/theory-lra-propagate.ts +1 -15
- package/src/prover/smt/solver/theory-lra-state.ts +3 -8
- package/src/prover/smt/solver/theory-lra.ts +1 -8
- package/src/prover/smt/solver/var-subst.ts +2 -26
- package/src/prover/smt/table.ts +0 -8
- package/src/prover/tlapm/cache.ts +20 -25
- package/src/prover/tlapm/ocaml-marshal.ts +19 -21
- package/src/prover/tlapm/tlapm.ts +12 -17
- package/src/prover/verdict.ts +0 -2
- package/src/prover/zenon/check/check.ts +0 -9
- package/src/prover/zenon/check/definitions.ts +5 -15
- package/src/prover/zenon/check/equality.ts +0 -8
- package/src/prover/zenon/check/functions.ts +0 -4
- package/src/prover/zenon/check/keys.ts +0 -7
- package/src/prover/zenon/check/propositional.ts +0 -3
- package/src/prover/zenon/check/records.ts +0 -5
- package/src/prover/zenon/check/relations.ts +0 -13
- package/src/prover/zenon/check/rewrites.ts +0 -6
- package/src/prover/zenon/check/sets.ts +0 -3
- package/src/prover/zenon/check/terms.ts +0 -17
- package/src/prover/zenon/check/tla.ts +0 -6
- package/src/prover/zenon/decide.ts +0 -12
- package/src/prover/zenon/encode.ts +1 -8
- package/src/prover/zenon/eqrel.ts +0 -13
- package/src/prover/zenon/equality-rules.ts +0 -4
- package/src/prover/zenon/expr.ts +1 -26
- package/src/prover/zenon/index-table.ts +17 -38
- package/src/prover/zenon/isar-case.ts +9 -19
- package/src/prover/zenon/isar.ts +1 -29
- package/src/prover/zenon/limits.ts +0 -4
- package/src/prover/zenon/llproof.ts +0 -9
- package/src/prover/zenon/mltoll.ts +54 -76
- package/src/prover/zenon/node.ts +1 -11
- package/src/prover/zenon/ocaml.ts +1 -17
- package/src/prover/zenon/parse.ts +2 -7
- package/src/prover/zenon/phrase.ts +1 -11
- package/src/prover/zenon/proof.ts +0 -9
- package/src/prover/zenon/propositional-rules.ts +0 -5
- package/src/prover/zenon/rules.ts +2 -6
- package/src/prover/zenon/search.ts +1 -17
- package/src/prover/zenon/tla/functions.ts +57 -29
- package/src/prover/zenon/tla/llproof.ts +63 -70
- package/src/prover/zenon/tla/records.ts +56 -27
- package/src/prover/zenon/tla/rewrites.ts +12 -19
- package/src/prover/zenon/tla/sets.ts +68 -39
- package/src/prover/zenon/tla/terms.ts +0 -6
- package/src/prover/zenon/tla/tla.ts +59 -58
- package/src/randomization.ts +81 -35
- package/src/resolve.ts +12 -112
- package/src/runtime.ts +22 -22
- package/src/sany/builtins.ts +2 -5
- package/src/sany/generator.ts +149 -252
- package/src/sany/levels.ts +6 -34
- package/src/sany/lexer.ts +41 -61
- package/src/sany/linter.ts +1 -9
- package/src/sany/modules.ts +1 -5
- package/src/sany/nodes.ts +0 -31
- package/src/sany/parse-error.ts +39 -117
- package/src/sany/report.ts +29 -63
- package/src/sany/selectors.ts +15 -39
- package/src/sany/source.ts +1 -17
- package/src/sany/xml.ts +13 -63
- package/src/search.ts +495 -155
- package/src/simulate.ts +685 -0
- package/src/spec-description.ts +176 -69
- package/src/standard-definitions.ts +0 -4
- package/src/standard-modules.ts +254 -69
- package/src/state-graph.ts +50 -24
- package/src/subexpressions.ts +69 -52
- package/src/substitution-levels.ts +2 -3
- package/src/successors.ts +263 -94
- package/src/symmetry.ts +33 -25
- package/src/tableau.ts +27 -24
- package/src/tlc/fingerprint.ts +183 -67
- package/src/tlc/jar-data.ts +112 -6
- package/src/tlc/messages.ts +110 -44
- package/src/tlc/order.ts +37 -60
- package/src/tlc/random.ts +33 -45
- package/src/tlc/replay.ts +549 -217
- package/src/tlc/summary.ts +36 -47
- package/src/tlc/tlc-operators.ts +76 -41
- package/src/tlc/tlcext-operators.ts +139 -122
- package/src/tlc/trace-spec.ts +269 -0
- package/src/tlc/value-stream.ts +139 -0
- package/src/tlc/version.ts +1 -4
- package/src/transfer.ts +22 -25
- package/src/typescript/actions.ts +481 -0
- package/src/typescript/collections.ts +600 -0
- package/src/typescript/compile.ts +65 -0
- package/src/typescript/context.ts +94 -0
- package/src/typescript/emit.ts +121 -0
- package/src/typescript/expressions.ts +496 -0
- package/src/typescript/formula.ts +152 -0
- package/src/typescript/functions.ts +284 -0
- package/src/typescript/model.ts +163 -0
- package/src/typescript/names.ts +114 -0
- package/src/typescript/program.ts +48 -0
- package/src/typescript/properties.ts +139 -0
- package/src/typescript/scope.ts +112 -0
- package/src/typescript/steps.ts +165 -0
- package/src/typescript/types.ts +171 -0
- package/src/values.ts +780 -337
- package/src/worker.ts +7 -8
package/src/tlc/replay.ts
CHANGED
|
@@ -1,14 +1,24 @@
|
|
|
1
1
|
import type { Expression, SourceLocation } from "../ast";
|
|
2
2
|
import { TlaEvaluationError } from "../errors";
|
|
3
3
|
import { isConstantLevel } from "../dependencies";
|
|
4
|
+
import {
|
|
5
|
+
countCoverage,
|
|
6
|
+
costCoverage,
|
|
7
|
+
getCoverageNode,
|
|
8
|
+
runAtCoverageNode,
|
|
9
|
+
type Coverage,
|
|
10
|
+
} from "../coverage";
|
|
4
11
|
import {
|
|
5
12
|
bindDefinitions,
|
|
6
13
|
bindLazyArguments,
|
|
7
14
|
bindOperatorArguments,
|
|
15
|
+
describeRange,
|
|
8
16
|
evaluate,
|
|
9
|
-
|
|
17
|
+
forEachBoundElement,
|
|
10
18
|
freezeCallStack,
|
|
11
19
|
getLazyFunction,
|
|
20
|
+
getQuantifierElements,
|
|
21
|
+
mapBoundSets,
|
|
12
22
|
toKeepLazyContext,
|
|
13
23
|
lookupScope,
|
|
14
24
|
resolveApplyOperator,
|
|
@@ -20,41 +30,46 @@ import {
|
|
|
20
30
|
type State,
|
|
21
31
|
toUnspecifiedSubscriptError,
|
|
22
32
|
} from "../evaluate";
|
|
23
|
-
import {
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
33
|
+
import {
|
|
34
|
+
getStreamedElements,
|
|
35
|
+
isEqualLikeTlc,
|
|
36
|
+
isTlcEnumerable,
|
|
37
|
+
setTrace,
|
|
38
|
+
type Value,
|
|
39
|
+
} from "../values";
|
|
40
|
+
import { substitutionFrames } from "../instances";
|
|
41
|
+
import { MESSAGE_CODE } from "./messages";
|
|
30
42
|
|
|
31
43
|
interface ReplayAction {
|
|
32
44
|
expression: Expression;
|
|
33
45
|
scope: Scope | undefined;
|
|
34
46
|
}
|
|
35
47
|
|
|
36
|
-
// TLC's ActionItemList: the conjuncts left to process, the first at the head.
|
|
37
48
|
interface ActionItem {
|
|
38
49
|
kind: "Predicate" | "Unchanged" | "Changed";
|
|
39
50
|
expression: Expression;
|
|
40
51
|
scope: Scope | undefined;
|
|
52
|
+
node: number;
|
|
41
53
|
rest: ActionItem | undefined;
|
|
42
54
|
}
|
|
43
55
|
|
|
44
56
|
interface Replay {
|
|
45
57
|
environment: Environment;
|
|
46
|
-
callStack: CallStack;
|
|
58
|
+
callStack: CallStack | undefined;
|
|
59
|
+
coverage: Coverage | undefined;
|
|
47
60
|
isInit: boolean;
|
|
48
|
-
// Whether the replay computes ENABLED rather than the successors of the state.
|
|
49
61
|
isEnabled: boolean;
|
|
50
|
-
// The state whose successors the replay computes.
|
|
51
62
|
current: Value[] | undefined;
|
|
52
63
|
onState: (state: Value[]) => void;
|
|
64
|
+
onIncomplete: ((state: State) => void) | undefined;
|
|
53
65
|
}
|
|
54
66
|
|
|
55
67
|
const withFrame = <Result>(replay: Replay, expression: Expression, run: () => Result): Result => {
|
|
56
68
|
const callStack = replay.callStack;
|
|
57
|
-
callStack
|
|
69
|
+
if (!callStack) return run();
|
|
70
|
+
const isEntered = callStack.expressions.at(-1) === expression;
|
|
71
|
+
const frames = (!isEntered && substitutionFrames.get(expression)) || [];
|
|
72
|
+
callStack.expressions.push(...frames, expression);
|
|
58
73
|
const outerSets = setTrace.sets;
|
|
59
74
|
const sets = outerSets ?? [];
|
|
60
75
|
const depth = sets.length;
|
|
@@ -62,16 +77,38 @@ const withFrame = <Result>(replay: Replay, expression: Expression, run: () => Re
|
|
|
62
77
|
try {
|
|
63
78
|
return run();
|
|
64
79
|
} catch (error) {
|
|
65
|
-
// A quantifier enumerates its bounds outside any evaluation.
|
|
66
80
|
freezeCallStack(callStack, sets.slice(depth), error);
|
|
67
81
|
throw error;
|
|
68
82
|
} finally {
|
|
69
|
-
if (!callStack.isFrozen) callStack.expressions.
|
|
83
|
+
if (!callStack.isFrozen) callStack.expressions.length -= frames.length + 1;
|
|
70
84
|
sets.length = depth;
|
|
71
85
|
setTrace.sets = outerSets;
|
|
72
86
|
}
|
|
73
87
|
};
|
|
74
88
|
|
|
89
|
+
const getNode = (replay: Replay, node: number, expression: Expression) =>
|
|
90
|
+
replay.coverage ? getCoverageNode(replay.coverage, node, expression) : -1;
|
|
91
|
+
|
|
92
|
+
const runAt = <Result>(replay: Replay, node: number, run: () => Result) =>
|
|
93
|
+
replay.coverage ? runAtCoverageNode(replay.coverage, node, run) : run();
|
|
94
|
+
|
|
95
|
+
const evaluateAt = (replay: Replay, node: number, expression: Expression, context: Context) =>
|
|
96
|
+
runAt(replay, node, () => evaluate(expression, context));
|
|
97
|
+
|
|
98
|
+
const evaluateOperatorAt = (
|
|
99
|
+
replay: Replay,
|
|
100
|
+
node: number,
|
|
101
|
+
expression: Expression,
|
|
102
|
+
context: Context,
|
|
103
|
+
) => {
|
|
104
|
+
const value = evaluateAt(replay, node, expression, context);
|
|
105
|
+
const coverage = replay.coverage;
|
|
106
|
+
if (coverage?.covered.has(expression)) {
|
|
107
|
+
for (let item = node; item !== -1; item = coverage.prefixes[item]) coverage.primary[item]--;
|
|
108
|
+
}
|
|
109
|
+
return value;
|
|
110
|
+
};
|
|
111
|
+
|
|
75
112
|
const getContext = (replay: Replay, scope: Scope | undefined, partial: State): Context =>
|
|
76
113
|
replay.isInit
|
|
77
114
|
? { environment: replay.environment, scope, state: partial, next: undefined }
|
|
@@ -87,8 +124,6 @@ const assign = (partial: State, index: number, value: Value) => {
|
|
|
87
124
|
return copy;
|
|
88
125
|
};
|
|
89
126
|
|
|
90
|
-
// SANY parses an infix chain such as A /\ B /\ C as (A /\ B) /\ C, where tla-ts keeps one
|
|
91
|
-
// junction, so the replay recreates the node of each prefix.
|
|
92
127
|
const getPrefix = (expression: Expression & { kind: "And" | "Or" }, count: number): Expression => {
|
|
93
128
|
const first = expression.operands[0].location;
|
|
94
129
|
const range = expression.location.range;
|
|
@@ -98,48 +133,48 @@ const getPrefix = (expression: Expression & { kind: "And" | "Or" }, count: numbe
|
|
|
98
133
|
return { ...expression, operands: expression.operands.slice(0, count), location };
|
|
99
134
|
};
|
|
100
135
|
|
|
136
|
+
const getPrefixNode = (replay: Replay, node: number) =>
|
|
137
|
+
replay.coverage ? replay.coverage.prefixes[node] : -1;
|
|
138
|
+
|
|
101
139
|
const getIdentifierName = (expression: Expression) =>
|
|
102
140
|
expression.kind === "Identifier" ? expression.name : undefined;
|
|
103
141
|
|
|
104
|
-
// The state variable an expression names, as TLC's getVar finds it through definitions and
|
|
105
|
-
// operator arguments.
|
|
106
142
|
const getVariable = (
|
|
107
|
-
|
|
143
|
+
environment: Environment,
|
|
108
144
|
expression: Expression,
|
|
109
145
|
scope: Scope | undefined,
|
|
110
146
|
): number | undefined => {
|
|
111
|
-
if (expression.kind === "Label") return getVariable(
|
|
147
|
+
if (expression.kind === "Label") return getVariable(environment, expression.body, scope);
|
|
112
148
|
const name = getIdentifierName(expression);
|
|
113
149
|
if (name === undefined) return undefined;
|
|
114
150
|
const binding = lookupScope(scope, name);
|
|
115
|
-
if (binding?.kind === "Thunk") return getVariable(
|
|
151
|
+
if (binding?.kind === "Thunk") return getVariable(environment, binding.expression, binding.scope);
|
|
116
152
|
if (binding) return undefined;
|
|
117
|
-
const index =
|
|
153
|
+
const index = environment.variableIndex.get(name);
|
|
118
154
|
if (index !== undefined) return index;
|
|
119
|
-
const operator = resolveGlobalOperator(name,
|
|
155
|
+
const operator = resolveGlobalOperator(name, environment);
|
|
120
156
|
return operator?.kind === "Closure" && operator.params.length === 0
|
|
121
|
-
? getVariable(
|
|
157
|
+
? getVariable(environment, operator.body, operator.scope)
|
|
122
158
|
: undefined;
|
|
123
159
|
};
|
|
124
160
|
|
|
125
|
-
// The variable a primed expression such as x' assigns, as TLC's getPrimedVar finds it.
|
|
126
161
|
const getPrimedVariable = (
|
|
127
|
-
|
|
162
|
+
environment: Environment,
|
|
128
163
|
expression: Expression,
|
|
129
164
|
scope: Scope | undefined,
|
|
130
165
|
): number | undefined => {
|
|
131
|
-
if (expression.kind === "Prime") return getVariable(
|
|
132
|
-
if (expression.kind === "Label") return getPrimedVariable(
|
|
166
|
+
if (expression.kind === "Prime") return getVariable(environment, expression.expression, scope);
|
|
167
|
+
if (expression.kind === "Label") return getPrimedVariable(environment, expression.body, scope);
|
|
133
168
|
const name = getIdentifierName(expression);
|
|
134
169
|
if (name === undefined) return undefined;
|
|
135
170
|
const binding = lookupScope(scope, name);
|
|
136
171
|
if (binding?.kind === "Thunk") {
|
|
137
|
-
return getPrimedVariable(
|
|
172
|
+
return getPrimedVariable(environment, binding.expression, binding.scope);
|
|
138
173
|
}
|
|
139
174
|
if (binding) return undefined;
|
|
140
|
-
const operator = resolveGlobalOperator(name,
|
|
175
|
+
const operator = resolveGlobalOperator(name, environment);
|
|
141
176
|
return operator?.kind === "Closure" && operator.params.length === 0
|
|
142
|
-
? getPrimedVariable(
|
|
177
|
+
? getPrimedVariable(environment, operator.body, operator.scope)
|
|
143
178
|
: undefined;
|
|
144
179
|
};
|
|
145
180
|
|
|
@@ -149,37 +184,56 @@ const isTrue = (value: Value) => {
|
|
|
149
184
|
return value;
|
|
150
185
|
};
|
|
151
186
|
|
|
152
|
-
// Once every variable has a value, TLC's getInitStates and getNextStatesAllAssigned evaluate the
|
|
153
|
-
// conjuncts left instead of walking them, so a disjunction among them takes one step. Its enabled
|
|
154
|
-
// doesn't, and Tool#getNextStates0 takes this shortcut only with warnings on.
|
|
155
187
|
export const isAssignedShortcut = (replay: Pick<Replay, "environment" | "isInit" | "isEnabled">) =>
|
|
156
188
|
!replay.isEnabled && (replay.isInit || replay.environment.runtime.isWarningEnabled);
|
|
157
189
|
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
190
|
+
const proceed = (
|
|
191
|
+
replay: Replay,
|
|
192
|
+
items: ActionItem | undefined,
|
|
193
|
+
partial: State,
|
|
194
|
+
node: number,
|
|
195
|
+
): boolean => {
|
|
196
|
+
const isProduced = proceedItems(replay, items, partial, node);
|
|
197
|
+
if (isProduced && replay.coverage && !replay.isInit) countCoverage(replay.coverage, node);
|
|
198
|
+
return isProduced;
|
|
199
|
+
};
|
|
200
|
+
|
|
201
|
+
const addState = (replay: Replay, state: Value[], node: number) => {
|
|
202
|
+
const coverage = replay.coverage;
|
|
203
|
+
if (coverage && replay.isInit) {
|
|
204
|
+
countCoverage(coverage, node);
|
|
205
|
+
countCoverage(coverage, coverage.roots[node]);
|
|
206
|
+
}
|
|
207
|
+
replay.onState(state);
|
|
208
|
+
return true;
|
|
209
|
+
};
|
|
210
|
+
|
|
211
|
+
const proceedItems = (
|
|
212
|
+
replay: Replay,
|
|
213
|
+
items: ActionItem | undefined,
|
|
214
|
+
partial: State,
|
|
215
|
+
node: number,
|
|
216
|
+
): boolean => {
|
|
161
217
|
if (items === undefined) {
|
|
162
|
-
if (isComplete(partial)) replay
|
|
163
|
-
|
|
218
|
+
if (isComplete(partial)) return addState(replay, partial, node);
|
|
219
|
+
replay.onIncomplete?.(partial);
|
|
220
|
+
return false;
|
|
164
221
|
}
|
|
165
222
|
if (isComplete(partial) && isAssignedShortcut(replay)) {
|
|
166
|
-
proceedAssigned(replay, items, partial);
|
|
167
|
-
return;
|
|
223
|
+
return proceedAssigned(replay, items, partial, node);
|
|
168
224
|
}
|
|
169
225
|
if (items.kind === "Predicate") {
|
|
170
|
-
visit(replay, items.expression, items.rest, items.scope, partial);
|
|
171
|
-
return;
|
|
226
|
+
return visit(replay, items.expression, items.rest, items.scope, partial, items.node);
|
|
172
227
|
}
|
|
173
228
|
if (items.kind === "Unchanged") {
|
|
174
|
-
visitUnchanged(replay, items.expression, items.rest, items.scope, partial);
|
|
175
|
-
return;
|
|
229
|
+
return visitUnchanged(replay, items.expression, items.rest, items.scope, partial, items.node);
|
|
176
230
|
}
|
|
177
|
-
|
|
231
|
+
return isChanged(replay, items, partial) && proceed(replay, items.rest, partial, items.node);
|
|
178
232
|
};
|
|
179
233
|
|
|
180
234
|
const isChanged = (replay: Replay, item: ActionItem, partial: State) => {
|
|
181
235
|
const environment = replay.environment;
|
|
182
|
-
const before =
|
|
236
|
+
const before = evaluateAt(replay, item.node, item.expression, {
|
|
183
237
|
environment,
|
|
184
238
|
scope: item.scope,
|
|
185
239
|
state: replay.current,
|
|
@@ -187,7 +241,7 @@ const isChanged = (replay: Replay, item: ActionItem, partial: State) => {
|
|
|
187
241
|
});
|
|
188
242
|
const after = (() => {
|
|
189
243
|
try {
|
|
190
|
-
return
|
|
244
|
+
return evaluateAt(replay, item.node, item.expression, {
|
|
191
245
|
environment,
|
|
192
246
|
scope: item.scope,
|
|
193
247
|
state: partial,
|
|
@@ -199,24 +253,37 @@ const isChanged = (replay: Replay, item: ActionItem, partial: State) => {
|
|
|
199
253
|
: error;
|
|
200
254
|
}
|
|
201
255
|
})();
|
|
202
|
-
|
|
256
|
+
try {
|
|
257
|
+
return !isEqualLikeTlc(before, after);
|
|
258
|
+
} catch (error) {
|
|
259
|
+
if (replay.callStack) freezeCallStack(replay.callStack, [before], error);
|
|
260
|
+
throw error;
|
|
261
|
+
}
|
|
203
262
|
};
|
|
204
263
|
|
|
205
|
-
const proceedAssigned = (
|
|
264
|
+
const proceedAssigned = (
|
|
265
|
+
replay: Replay,
|
|
266
|
+
items: ActionItem | undefined,
|
|
267
|
+
partial: Value[],
|
|
268
|
+
node: number,
|
|
269
|
+
): boolean => {
|
|
206
270
|
for (let item = items; item !== undefined; item = item.rest) {
|
|
207
271
|
if (item.kind === "Unchanged") {
|
|
208
|
-
visitUnchanged(replay, item.expression, item.rest, item.scope, partial);
|
|
209
|
-
return;
|
|
272
|
+
return visitUnchanged(replay, item.expression, item.rest, item.scope, partial, item.node);
|
|
210
273
|
}
|
|
211
|
-
|
|
274
|
+
const isHeld =
|
|
212
275
|
item.kind === "Changed"
|
|
213
|
-
?
|
|
214
|
-
:
|
|
215
|
-
|
|
216
|
-
|
|
276
|
+
? isChanged(replay, item, partial)
|
|
277
|
+
: isTrue(
|
|
278
|
+
evaluateAt(replay, item.node, item.expression, getContext(replay, item.scope, partial)),
|
|
279
|
+
);
|
|
280
|
+
if (!isHeld) {
|
|
281
|
+
const coverage = replay.coverage;
|
|
282
|
+
if (coverage && replay.isInit) coverage.secondary[coverage.roots[node]]++;
|
|
283
|
+
return false;
|
|
217
284
|
}
|
|
218
285
|
}
|
|
219
|
-
replay
|
|
286
|
+
return addState(replay, partial, node);
|
|
220
287
|
};
|
|
221
288
|
|
|
222
289
|
const visit = (
|
|
@@ -225,39 +292,71 @@ const visit = (
|
|
|
225
292
|
items: ActionItem | undefined,
|
|
226
293
|
scope: Scope | undefined,
|
|
227
294
|
partial: State,
|
|
228
|
-
|
|
295
|
+
parent: number,
|
|
296
|
+
): boolean =>
|
|
297
|
+
visitAt(replay, expression, items, scope, partial, getNode(replay, parent, expression));
|
|
298
|
+
|
|
299
|
+
const visitAt = (
|
|
300
|
+
replay: Replay,
|
|
301
|
+
expression: Expression,
|
|
302
|
+
items: ActionItem | undefined,
|
|
303
|
+
scope: Scope | undefined,
|
|
304
|
+
partial: State,
|
|
305
|
+
node: number,
|
|
306
|
+
): boolean =>
|
|
229
307
|
withFrame(replay, expression, () => {
|
|
230
308
|
switch (expression.kind) {
|
|
231
|
-
case "Let":
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
309
|
+
case "Let": {
|
|
310
|
+
const context = getContext(replay, scope, partial);
|
|
311
|
+
const definitions = expression.definitions;
|
|
312
|
+
const bound = replay.coverage
|
|
313
|
+
? bindDefinitions(definitions, context, {
|
|
314
|
+
impure: new Set(definitions),
|
|
315
|
+
streamed: new Set(),
|
|
316
|
+
})
|
|
317
|
+
: bindDefinitions(definitions, context);
|
|
318
|
+
return visit(replay, expression.body, items, bound, partial, node);
|
|
319
|
+
}
|
|
240
320
|
case "Label":
|
|
241
|
-
visit(replay, expression.body, items, scope, partial);
|
|
242
|
-
return;
|
|
321
|
+
return visit(replay, expression.body, items, scope, partial, node);
|
|
243
322
|
default:
|
|
244
323
|
if (LITERAL_KINDS.has(expression.kind))
|
|
245
324
|
throw new TlaEvaluationError("The state relation is not a boolean expression.");
|
|
246
|
-
withFrame(replay, expression, () =>
|
|
247
|
-
visitApplication(replay, expression, items, scope, partial),
|
|
325
|
+
return withFrame(replay, expression, () =>
|
|
326
|
+
visitApplication(replay, expression, items, scope, partial, node),
|
|
248
327
|
);
|
|
249
328
|
}
|
|
250
329
|
});
|
|
251
330
|
|
|
252
|
-
// The value of a user-defined operator TLC evaluates instead of walking its body.
|
|
253
331
|
const visitValue = (
|
|
254
332
|
replay: Replay,
|
|
255
333
|
value: Value,
|
|
256
334
|
items: ActionItem | undefined,
|
|
257
335
|
partial: State,
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
|
|
336
|
+
node: number,
|
|
337
|
+
) => isTrue(value) && proceed(replay, items, partial, node);
|
|
338
|
+
|
|
339
|
+
const BUILT_IN_OPERATORS = new Set([
|
|
340
|
+
"=",
|
|
341
|
+
"#",
|
|
342
|
+
"~",
|
|
343
|
+
"<=>",
|
|
344
|
+
"/\\",
|
|
345
|
+
"\\/",
|
|
346
|
+
"=>",
|
|
347
|
+
"\\in",
|
|
348
|
+
"\\notin",
|
|
349
|
+
"\\subseteq",
|
|
350
|
+
"\\cup",
|
|
351
|
+
"\\cap",
|
|
352
|
+
"\\",
|
|
353
|
+
"SUBSET",
|
|
354
|
+
"UNION",
|
|
355
|
+
"DOMAIN",
|
|
356
|
+
"~>",
|
|
357
|
+
"-+->",
|
|
358
|
+
"\\cdot",
|
|
359
|
+
]);
|
|
261
360
|
|
|
262
361
|
const visitDefined = (
|
|
263
362
|
replay: Replay,
|
|
@@ -265,21 +364,21 @@ const visitDefined = (
|
|
|
265
364
|
items: ActionItem | undefined,
|
|
266
365
|
scope: Scope | undefined,
|
|
267
366
|
partial: State,
|
|
268
|
-
|
|
367
|
+
node: number,
|
|
368
|
+
): boolean => {
|
|
269
369
|
const context = getContext(replay, scope, partial);
|
|
270
370
|
if (expression.kind === "Identifier") {
|
|
271
371
|
const binding = lookupScope(scope, expression.name);
|
|
272
372
|
if (binding?.kind === "Thunk" && binding.cache === undefined) {
|
|
273
|
-
|
|
274
|
-
return;
|
|
373
|
+
const thunkNode = replay.coverage?.values.get(binding) ?? node;
|
|
374
|
+
return visit(replay, binding.expression, items, binding.scope, partial, thunkNode);
|
|
275
375
|
}
|
|
276
376
|
if (
|
|
277
377
|
binding?.kind === "Operator" &&
|
|
278
378
|
binding.operator.kind === "Closure" &&
|
|
279
379
|
binding.operator.params.length === 0
|
|
280
380
|
) {
|
|
281
|
-
visit(replay, binding.operator.body, items, binding.operator.scope, partial);
|
|
282
|
-
return;
|
|
381
|
+
return visit(replay, binding.operator.body, items, binding.operator.scope, partial, node);
|
|
283
382
|
}
|
|
284
383
|
const definition = binding ? undefined : replay.environment.definitions.get(expression.name);
|
|
285
384
|
const operator = binding
|
|
@@ -291,48 +390,54 @@ const visitDefined = (
|
|
|
291
390
|
!replay.environment.variableIndex.has(expression.name) &&
|
|
292
391
|
!(definition && isConstantLevel(definition, replay.environment))
|
|
293
392
|
) {
|
|
294
|
-
visit(replay, operator.body, items, operator.scope, partial);
|
|
295
|
-
return;
|
|
393
|
+
return visit(replay, operator.body, items, operator.scope, partial, node);
|
|
296
394
|
}
|
|
297
|
-
visitValue(
|
|
298
|
-
|
|
395
|
+
return visitValue(
|
|
396
|
+
replay,
|
|
397
|
+
evaluateOperatorAt(replay, node, expression, context),
|
|
398
|
+
items,
|
|
399
|
+
partial,
|
|
400
|
+
node,
|
|
401
|
+
);
|
|
299
402
|
}
|
|
300
403
|
const operator = resolveApplyOperator(expression, context);
|
|
301
404
|
if (operator?.kind === "Closure" && operator.params.length === expression.args.length) {
|
|
302
|
-
|
|
303
|
-
replay,
|
|
304
|
-
operator.body,
|
|
305
|
-
items,
|
|
405
|
+
const bound = runAt(replay, node, () =>
|
|
306
406
|
bindOperatorArguments(operator, expression.args, context),
|
|
307
|
-
partial,
|
|
308
407
|
);
|
|
309
|
-
return;
|
|
408
|
+
return visit(replay, operator.body, items, bound, partial, node);
|
|
310
409
|
}
|
|
311
|
-
|
|
410
|
+
const value = BUILT_IN_OPERATORS.has(expression.operator)
|
|
411
|
+
? evaluateAt(replay, node, expression, context)
|
|
412
|
+
: evaluateOperatorAt(replay, node, expression, context);
|
|
413
|
+
return visitValue(replay, value, items, partial, node);
|
|
312
414
|
};
|
|
313
415
|
|
|
314
|
-
// A variable takes the value when it has none yet, and otherwise must already have it.
|
|
315
416
|
const proceedWithValue = (
|
|
316
417
|
replay: Replay,
|
|
317
418
|
items: ActionItem | undefined,
|
|
318
419
|
partial: State,
|
|
319
420
|
index: number,
|
|
320
421
|
value: Value,
|
|
422
|
+
node: number,
|
|
321
423
|
) => {
|
|
322
424
|
const assigned = partial[index];
|
|
323
|
-
if (assigned === undefined)
|
|
324
|
-
|
|
325
|
-
return;
|
|
326
|
-
}
|
|
327
|
-
if (valuesEqual(assigned, value)) proceed(replay, items, partial);
|
|
425
|
+
if (assigned === undefined) return proceed(replay, items, assign(partial, index, value), node);
|
|
426
|
+
return isEqualLikeTlc(assigned, value) && proceed(replay, items, partial, node);
|
|
328
427
|
};
|
|
329
428
|
|
|
330
429
|
const createItem = (
|
|
331
430
|
kind: ActionItem["kind"],
|
|
332
431
|
expression: Expression,
|
|
333
432
|
scope: Scope | undefined,
|
|
433
|
+
node: number,
|
|
334
434
|
rest: ActionItem | undefined,
|
|
335
|
-
): ActionItem => ({ kind, expression, scope, rest });
|
|
435
|
+
): ActionItem => ({ kind, expression, scope, node, rest });
|
|
436
|
+
|
|
437
|
+
const getEnumerated = (replay: Replay, set: Value, elements: Value[]) => {
|
|
438
|
+
if (replay.coverage) costCoverage(replay.coverage, set, elements.length + 1);
|
|
439
|
+
return elements;
|
|
440
|
+
};
|
|
336
441
|
|
|
337
442
|
const visitAssignment = (
|
|
338
443
|
replay: Replay,
|
|
@@ -340,65 +445,119 @@ const visitAssignment = (
|
|
|
340
445
|
items: ActionItem | undefined,
|
|
341
446
|
scope: Scope | undefined,
|
|
342
447
|
partial: State,
|
|
448
|
+
node: number,
|
|
343
449
|
) => {
|
|
344
450
|
const [target, source] = expression.args;
|
|
345
451
|
const index = replay.isInit
|
|
346
|
-
? getVariable(replay, target, scope)
|
|
347
|
-
: getPrimedVariable(replay, target, scope);
|
|
452
|
+
? getVariable(replay.environment, target, scope)
|
|
453
|
+
: getPrimedVariable(replay.environment, target, scope);
|
|
348
454
|
const context = getContext(replay, scope, partial);
|
|
349
455
|
if (index === undefined) {
|
|
350
|
-
|
|
351
|
-
|
|
456
|
+
return (
|
|
457
|
+
evaluateAt(replay, node, expression, context) === true &&
|
|
458
|
+
proceed(replay, items, partial, node)
|
|
459
|
+
);
|
|
352
460
|
}
|
|
353
|
-
const value =
|
|
461
|
+
const value = evaluateAt(replay, node, source, context);
|
|
354
462
|
const assigned = partial[index];
|
|
355
463
|
if (expression.operator === "=") {
|
|
356
|
-
proceedWithValue(replay, items, partial, index, value);
|
|
357
|
-
return;
|
|
464
|
+
return proceedWithValue(replay, items, partial, index, value, node);
|
|
358
465
|
}
|
|
359
466
|
const set: Value = expression.operator === "\\subseteq" ? { kind: "Subset", base: value } : value;
|
|
467
|
+
if (typeof set === "object" && set !== value) replay.callStack?.sources.set(set, source);
|
|
360
468
|
if (assigned !== undefined) {
|
|
361
|
-
|
|
362
|
-
|
|
469
|
+
return (
|
|
470
|
+
evaluateAt(replay, node, expression, context) === true &&
|
|
471
|
+
proceed(replay, items, partial, node)
|
|
472
|
+
);
|
|
363
473
|
}
|
|
364
474
|
if (!isTlcEnumerable(set))
|
|
365
475
|
throw new TlaEvaluationError("The right side of \\IN is not enumerable.");
|
|
366
|
-
|
|
367
|
-
|
|
368
|
-
|
|
476
|
+
return getEnumerated(replay, set, getStreamedElements(set)).reduce<boolean>(
|
|
477
|
+
(isProduced, element) =>
|
|
478
|
+
proceed(replay, items, assign(partial, index, element), node) || isProduced,
|
|
479
|
+
false,
|
|
480
|
+
);
|
|
369
481
|
};
|
|
370
482
|
|
|
371
483
|
const ASSIGNMENT_OPERATORS = new Set(["=", "\\in", "\\subseteq"]);
|
|
372
484
|
|
|
373
485
|
export const LITERAL_KINDS = new Set<Expression["kind"]>(["Number", "Decimal", "String"]);
|
|
374
486
|
|
|
487
|
+
const ENABLED_TEMPORAL_FORMS: Partial<Record<Expression["kind"], string>> = {
|
|
488
|
+
Always: "[]",
|
|
489
|
+
Eventually: "<>",
|
|
490
|
+
WeakFairness: "WF",
|
|
491
|
+
StrongFairness: "SF",
|
|
492
|
+
};
|
|
493
|
+
|
|
494
|
+
export const getEnabledFailure = (expression: Expression) => {
|
|
495
|
+
const form =
|
|
496
|
+
expression.kind === "Apply" && (expression.operator === "~>" || expression.operator === "-+->")
|
|
497
|
+
? expression.operator === "~>"
|
|
498
|
+
? "a ~> b"
|
|
499
|
+
: "a -+-> formula"
|
|
500
|
+
: ENABLED_TEMPORAL_FORMS[expression.kind];
|
|
501
|
+
if (form !== undefined) {
|
|
502
|
+
return `In computing ENABLED, TLC encountered a temporal formula (${form}).\n${describeRange(expression)}`;
|
|
503
|
+
}
|
|
504
|
+
if (expression.kind === "UnboundedQuantifier") {
|
|
505
|
+
return expression.isTemporal
|
|
506
|
+
? `In computing ENABLED, TLC encountered temporal quantifier.\n${describeRange(expression)}`
|
|
507
|
+
: `In computing ENABLED, TLC encountered unbounded quantifier. Make sure that the expression is of form ${expression.quantifier === "Forall" ? "\\A" : "\\E"} x \\in S: P(x).\n${describeRange(expression)}`;
|
|
508
|
+
}
|
|
509
|
+
if (expression.kind === "Choose" && expression.set === undefined) {
|
|
510
|
+
return `In computing ENABLED, TLC encountered unbounded CHOOSE. Make sure that the expression is of form CHOOSE x \\in S: P(x).\n${describeRange(expression)}`;
|
|
511
|
+
}
|
|
512
|
+
return undefined;
|
|
513
|
+
};
|
|
514
|
+
|
|
515
|
+
const getBindings = (
|
|
516
|
+
replay: Replay,
|
|
517
|
+
expression: Expression & { kind: "Exists" | "Forall" },
|
|
518
|
+
context: Context,
|
|
519
|
+
node: number,
|
|
520
|
+
) => {
|
|
521
|
+
const bindings: (Scope | undefined)[] = [];
|
|
522
|
+
const version = replay.environment.runtime.version;
|
|
523
|
+
const sets = runAt(replay, node, () =>
|
|
524
|
+
mapBoundSets(expression.bounds, (set) => {
|
|
525
|
+
const value = evaluate(set, context);
|
|
526
|
+
const elements = getQuantifierElements(value, set, version);
|
|
527
|
+
if (Array.isArray(elements)) getEnumerated(replay, value, elements);
|
|
528
|
+
return elements;
|
|
529
|
+
}),
|
|
530
|
+
);
|
|
531
|
+
forEachBoundElement(expression.bounds, sets, context.scope, (bound) => {
|
|
532
|
+
bindings.push(bound);
|
|
533
|
+
return false;
|
|
534
|
+
});
|
|
535
|
+
return bindings;
|
|
536
|
+
};
|
|
537
|
+
|
|
375
538
|
const visitApplication = (
|
|
376
539
|
replay: Replay,
|
|
377
540
|
expression: Expression,
|
|
378
541
|
items: ActionItem | undefined,
|
|
379
542
|
scope: Scope | undefined,
|
|
380
543
|
partial: State,
|
|
381
|
-
|
|
544
|
+
node: number,
|
|
545
|
+
): boolean => {
|
|
382
546
|
const context = getContext(replay, scope, partial);
|
|
383
547
|
switch (expression.kind) {
|
|
384
548
|
case "Identifier":
|
|
385
|
-
visitDefined(replay, expression, items, scope, partial);
|
|
386
|
-
return;
|
|
549
|
+
return visitDefined(replay, expression, items, scope, partial, node);
|
|
387
550
|
case "Apply": {
|
|
388
551
|
if (ASSIGNMENT_OPERATORS.has(expression.operator) && expression.args.length === 2) {
|
|
389
|
-
visitAssignment(replay, expression, items, scope, partial);
|
|
390
|
-
return;
|
|
552
|
+
return visitAssignment(replay, expression, items, scope, partial, node);
|
|
391
553
|
}
|
|
392
554
|
if (expression.operator === "=>" && expression.args.length === 2) {
|
|
393
|
-
if (isTrue(
|
|
394
|
-
visit(replay, expression.args[1], items, scope, partial);
|
|
395
|
-
return;
|
|
555
|
+
if (isTrue(evaluateAt(replay, node, expression.args[0], context))) {
|
|
556
|
+
return visit(replay, expression.args[1], items, scope, partial, node);
|
|
396
557
|
}
|
|
397
|
-
proceed(replay, items, partial);
|
|
398
|
-
return;
|
|
558
|
+
return proceed(replay, items, partial, node);
|
|
399
559
|
}
|
|
400
|
-
visitDefined(replay, expression, items, scope, partial);
|
|
401
|
-
return;
|
|
560
|
+
return visitDefined(replay, expression, items, scope, partial, node);
|
|
402
561
|
}
|
|
403
562
|
case "And": {
|
|
404
563
|
const operands = expression.operands;
|
|
@@ -406,170 +565,213 @@ const visitApplication = (
|
|
|
406
565
|
const rest = operands
|
|
407
566
|
.slice(1)
|
|
408
567
|
.reduceRight<ActionItem | undefined>(
|
|
409
|
-
(tail, operand) => createItem("Predicate", operand, scope, tail),
|
|
568
|
+
(tail, operand) => createItem("Predicate", operand, scope, node, tail),
|
|
410
569
|
items,
|
|
411
570
|
);
|
|
412
|
-
visit(replay, operands[0], rest, scope, partial);
|
|
413
|
-
return;
|
|
571
|
+
return visit(replay, operands[0], rest, scope, partial, node);
|
|
414
572
|
}
|
|
415
573
|
const last = operands[operands.length - 1];
|
|
416
|
-
|
|
574
|
+
return visitAt(
|
|
417
575
|
replay,
|
|
418
576
|
getPrefix(expression, operands.length - 1),
|
|
419
|
-
createItem("Predicate", last, scope, items),
|
|
577
|
+
createItem("Predicate", last, scope, node, items),
|
|
420
578
|
scope,
|
|
421
579
|
partial,
|
|
580
|
+
getPrefixNode(replay, node),
|
|
422
581
|
);
|
|
423
|
-
return;
|
|
424
582
|
}
|
|
425
583
|
case "Or": {
|
|
426
584
|
const operands = expression.operands;
|
|
427
585
|
if (expression.isBulleted || operands.length === 2) {
|
|
428
|
-
operands.
|
|
429
|
-
|
|
586
|
+
return operands.reduce(
|
|
587
|
+
(isProduced, operand) =>
|
|
588
|
+
visit(replay, operand, items, scope, partial, node) || isProduced,
|
|
589
|
+
false,
|
|
590
|
+
);
|
|
430
591
|
}
|
|
431
|
-
|
|
432
|
-
|
|
433
|
-
|
|
592
|
+
const isPrefixProduced = visitAt(
|
|
593
|
+
replay,
|
|
594
|
+
getPrefix(expression, operands.length - 1),
|
|
595
|
+
items,
|
|
596
|
+
scope,
|
|
597
|
+
partial,
|
|
598
|
+
getPrefixNode(replay, node),
|
|
599
|
+
);
|
|
600
|
+
const isLastProduced = visit(
|
|
601
|
+
replay,
|
|
602
|
+
operands[operands.length - 1],
|
|
603
|
+
items,
|
|
604
|
+
scope,
|
|
605
|
+
partial,
|
|
606
|
+
node,
|
|
607
|
+
);
|
|
608
|
+
return isPrefixProduced || isLastProduced;
|
|
434
609
|
}
|
|
435
610
|
case "Exists":
|
|
436
|
-
|
|
437
|
-
|
|
438
|
-
|
|
439
|
-
|
|
440
|
-
|
|
611
|
+
return getBindings(replay, expression, context, node).reduce(
|
|
612
|
+
(isProduced, bound) =>
|
|
613
|
+
visit(replay, expression.body, items, bound, partial, node) || isProduced,
|
|
614
|
+
false,
|
|
615
|
+
);
|
|
441
616
|
case "Forall": {
|
|
442
|
-
const bounds
|
|
443
|
-
|
|
444
|
-
bounds.push(bound);
|
|
445
|
-
return false;
|
|
446
|
-
});
|
|
447
|
-
if (bounds.length === 0) {
|
|
448
|
-
proceed(replay, items, partial);
|
|
449
|
-
return;
|
|
450
|
-
}
|
|
451
|
-
// TLC adds each binding after the first to the front of the conjuncts left.
|
|
617
|
+
const bounds = getBindings(replay, expression, context, node);
|
|
618
|
+
if (bounds.length === 0) return proceed(replay, items, partial, node);
|
|
452
619
|
const rest = bounds
|
|
453
620
|
.slice(1)
|
|
454
621
|
.reduce<ActionItem | undefined>(
|
|
455
|
-
(tail, bound) => createItem("Predicate", expression.body, bound, tail),
|
|
622
|
+
(tail, bound) => createItem("Predicate", expression.body, bound, node, tail),
|
|
456
623
|
items,
|
|
457
624
|
);
|
|
458
|
-
visit(replay, expression.body, rest, bounds[0], partial);
|
|
459
|
-
return;
|
|
625
|
+
return visit(replay, expression.body, rest, bounds[0], partial, node);
|
|
460
626
|
}
|
|
461
627
|
case "If":
|
|
462
|
-
visit(
|
|
628
|
+
return visit(
|
|
463
629
|
replay,
|
|
464
|
-
isTrue(
|
|
630
|
+
isTrue(evaluateAt(replay, node, expression.condition, context))
|
|
465
631
|
? expression.consequent
|
|
466
632
|
: expression.alternative,
|
|
467
633
|
items,
|
|
468
634
|
scope,
|
|
469
635
|
partial,
|
|
636
|
+
node,
|
|
470
637
|
);
|
|
471
|
-
return;
|
|
472
638
|
case "Case": {
|
|
473
639
|
const arm = expression.arms.find((candidate) =>
|
|
474
|
-
isTrue(
|
|
640
|
+
isTrue(evaluateAt(replay, node, candidate.condition, context)),
|
|
475
641
|
);
|
|
476
642
|
const body = arm?.body ?? expression.other;
|
|
477
643
|
if (body === undefined) {
|
|
478
644
|
throw new TlaEvaluationError("TLC encountered a CASE with no conditions true.");
|
|
479
645
|
}
|
|
480
|
-
visit(replay, body, items, scope, partial);
|
|
481
|
-
return;
|
|
646
|
+
return visit(replay, body, items, scope, partial, node);
|
|
482
647
|
}
|
|
483
648
|
case "FunctionApplication": {
|
|
484
649
|
const lambda = getLazyFunction(
|
|
485
|
-
|
|
650
|
+
evaluateAt(
|
|
651
|
+
replay,
|
|
652
|
+
node,
|
|
653
|
+
expression.function,
|
|
654
|
+
replay.isInit ? context : toKeepLazyContext(context),
|
|
655
|
+
),
|
|
486
656
|
);
|
|
487
657
|
if (lambda) {
|
|
488
|
-
|
|
489
|
-
return;
|
|
658
|
+
const bound = runAt(replay, node, () => bindLazyArguments(lambda, expression, context));
|
|
659
|
+
return visit(replay, lambda.body, items, bound, partial, node);
|
|
490
660
|
}
|
|
491
661
|
break;
|
|
492
662
|
}
|
|
493
663
|
case "Unchanged":
|
|
494
664
|
if (!replay.isInit) {
|
|
495
|
-
visitUnchanged(replay, expression.expression, items, scope, partial);
|
|
496
|
-
return;
|
|
665
|
+
return visitUnchanged(replay, expression.expression, items, scope, partial, node);
|
|
497
666
|
}
|
|
498
667
|
break;
|
|
499
668
|
case "BoxAction":
|
|
500
669
|
if (!replay.isInit) {
|
|
501
|
-
visit(replay, expression.action, items, scope, partial);
|
|
502
|
-
|
|
503
|
-
|
|
670
|
+
const isProduced = visit(replay, expression.action, items, scope, partial, node);
|
|
671
|
+
return (
|
|
672
|
+
visitUnchanged(replay, expression.subscript, items, scope, partial, node) || isProduced
|
|
673
|
+
);
|
|
504
674
|
}
|
|
505
675
|
break;
|
|
506
676
|
case "AngleAction":
|
|
507
677
|
if (!replay.isInit) {
|
|
508
|
-
visit(
|
|
678
|
+
return visit(
|
|
509
679
|
replay,
|
|
510
680
|
expression.action,
|
|
511
|
-
createItem("Changed", expression.subscript, scope, items),
|
|
681
|
+
createItem("Changed", expression.subscript, scope, node, items),
|
|
512
682
|
scope,
|
|
513
683
|
partial,
|
|
684
|
+
node,
|
|
514
685
|
);
|
|
515
|
-
return;
|
|
516
686
|
}
|
|
517
687
|
break;
|
|
518
688
|
}
|
|
519
|
-
|
|
689
|
+
const failure = replay.isEnabled ? getEnabledFailure(expression) : undefined;
|
|
690
|
+
if (failure !== undefined) throw new TlaEvaluationError(failure);
|
|
691
|
+
return visitValue(replay, evaluateAt(replay, node, expression, context), items, partial, node);
|
|
520
692
|
};
|
|
521
693
|
|
|
522
|
-
|
|
694
|
+
export const warnChangedUnchanged = (
|
|
695
|
+
environment: Environment,
|
|
696
|
+
index: number,
|
|
697
|
+
expression: Expression,
|
|
698
|
+
) =>
|
|
699
|
+
environment.runtime.warn(
|
|
700
|
+
MESSAGE_CODE.unchangedVariableChanged,
|
|
701
|
+
`The variable ${environment.variables[index]} was changed while it is specified as UNCHANGED at\n${describeRange(expression)}`,
|
|
702
|
+
);
|
|
703
|
+
|
|
523
704
|
const visitUnchanged = (
|
|
524
705
|
replay: Replay,
|
|
525
706
|
expression: Expression,
|
|
526
707
|
items: ActionItem | undefined,
|
|
527
708
|
scope: Scope | undefined,
|
|
528
709
|
partial: State,
|
|
529
|
-
|
|
710
|
+
parent: number,
|
|
711
|
+
): boolean =>
|
|
530
712
|
withFrame(replay, expression, () => {
|
|
531
|
-
const
|
|
713
|
+
const node = getNode(replay, parent, expression);
|
|
714
|
+
const index = getVariable(replay.environment, expression, scope);
|
|
532
715
|
if (index !== undefined) {
|
|
533
716
|
const value = replay.current?.[index];
|
|
534
|
-
if (value
|
|
535
|
-
|
|
717
|
+
if (value === undefined) return false;
|
|
718
|
+
const assigned = partial[index];
|
|
719
|
+
if (assigned !== undefined && !isEqualLikeTlc(assigned, value)) {
|
|
720
|
+
warnChangedUnchanged(replay.environment, index, expression);
|
|
721
|
+
return false;
|
|
722
|
+
}
|
|
723
|
+
return proceedWithValue(replay, items, partial, index, value, node);
|
|
536
724
|
}
|
|
537
725
|
if (expression.kind === "Tuple") {
|
|
538
726
|
const [first, ...others] = expression.elements;
|
|
539
|
-
if (first === undefined)
|
|
540
|
-
proceed(replay, items, partial);
|
|
541
|
-
return;
|
|
542
|
-
}
|
|
727
|
+
if (first === undefined) return proceed(replay, items, partial, node);
|
|
543
728
|
const rest = others.reduceRight<ActionItem | undefined>(
|
|
544
|
-
(tail, element) => createItem("Unchanged", element, scope, tail),
|
|
729
|
+
(tail, element) => createItem("Unchanged", element, scope, node, tail),
|
|
545
730
|
items,
|
|
546
731
|
);
|
|
547
|
-
visitUnchanged(replay, first, rest, scope, partial);
|
|
548
|
-
return;
|
|
732
|
+
return visitUnchanged(replay, first, rest, scope, partial, node);
|
|
549
733
|
}
|
|
550
734
|
if (expression.kind === "Identifier") {
|
|
551
735
|
const binding = lookupScope(scope, expression.name);
|
|
552
736
|
if (binding?.kind === "Thunk") {
|
|
553
|
-
visitUnchanged(replay, binding.expression, items, binding.scope, partial);
|
|
554
|
-
return;
|
|
737
|
+
return visitUnchanged(replay, binding.expression, items, binding.scope, partial, node);
|
|
555
738
|
}
|
|
556
739
|
const operator = binding
|
|
557
740
|
? undefined
|
|
558
741
|
: resolveGlobalOperator(expression.name, replay.environment);
|
|
559
742
|
if (operator?.kind === "Closure" && operator.params.length === 0) {
|
|
560
|
-
visitUnchanged(replay, operator.body, items, operator.scope, partial);
|
|
561
|
-
|
|
743
|
+
return visitUnchanged(replay, operator.body, items, operator.scope, partial, node);
|
|
744
|
+
}
|
|
745
|
+
}
|
|
746
|
+
// Deviation from TLC: Tool#enabledUnchanged evaluates the application in the partial next state and fails on an unassigned variable.
|
|
747
|
+
if (replay.isEnabled && expression.kind === "Apply") {
|
|
748
|
+
const context = getContext(replay, scope, partial);
|
|
749
|
+
const operator = resolveApplyOperator(expression, context);
|
|
750
|
+
if (operator?.kind === "Closure" && operator.params.length === expression.args.length) {
|
|
751
|
+
return visitUnchanged(
|
|
752
|
+
replay,
|
|
753
|
+
operator.body,
|
|
754
|
+
items,
|
|
755
|
+
bindOperatorArguments(operator, expression.args, context),
|
|
756
|
+
partial,
|
|
757
|
+
node,
|
|
758
|
+
);
|
|
562
759
|
}
|
|
563
760
|
}
|
|
564
761
|
const environment = replay.environment;
|
|
565
|
-
const before =
|
|
762
|
+
const before = evaluateAt(replay, node, expression, {
|
|
566
763
|
environment,
|
|
567
764
|
scope,
|
|
568
765
|
state: replay.current,
|
|
569
766
|
next: undefined,
|
|
570
767
|
});
|
|
571
|
-
const after =
|
|
572
|
-
|
|
768
|
+
const after = evaluateAt(replay, node, expression, {
|
|
769
|
+
environment,
|
|
770
|
+
scope,
|
|
771
|
+
state: partial,
|
|
772
|
+
next: undefined,
|
|
773
|
+
});
|
|
774
|
+
return isEqualLikeTlc(before, after) && proceed(replay, items, partial, node);
|
|
573
775
|
});
|
|
574
776
|
|
|
575
777
|
const createReplay = (
|
|
@@ -578,16 +780,20 @@ const createReplay = (
|
|
|
578
780
|
current: Value[] | undefined,
|
|
579
781
|
onState: (state: Value[]) => void,
|
|
580
782
|
isEnabled = false,
|
|
581
|
-
|
|
582
|
-
|
|
583
|
-
|
|
584
|
-
|
|
585
|
-
|
|
783
|
+
onIncomplete?: (state: State) => void,
|
|
784
|
+
): Replay => ({
|
|
785
|
+
environment,
|
|
786
|
+
callStack: environment.callStack,
|
|
787
|
+
coverage: environment.coverage,
|
|
788
|
+
isInit,
|
|
789
|
+
isEnabled,
|
|
790
|
+
current,
|
|
791
|
+
onState,
|
|
792
|
+
onIncomplete,
|
|
793
|
+
});
|
|
586
794
|
|
|
587
795
|
const ENABLED_FOUND = new Error("The replay found a successor");
|
|
588
796
|
|
|
589
|
-
// TLC's Tool#enabled, which walks the action as getNextStates does and stops at the first
|
|
590
|
-
// successor.
|
|
591
797
|
export const replayEnabled = (
|
|
592
798
|
expression: Expression,
|
|
593
799
|
scope: Scope | undefined,
|
|
@@ -603,57 +809,183 @@ export const replayEnabled = (
|
|
|
603
809
|
},
|
|
604
810
|
true,
|
|
605
811
|
);
|
|
606
|
-
const
|
|
812
|
+
const callStack = replay.callStack;
|
|
813
|
+
const depth = callStack?.expressions.length ?? 0;
|
|
607
814
|
try {
|
|
608
|
-
// The ENABLED of a fairness condition WF_v(A) passes A to TLC's enabled with v to change, where
|
|
609
|
-
// liveness.ts builds <<A>>_v at the location of A.
|
|
610
815
|
if (expression.kind === "AngleAction" && expression.location === expression.action.location) {
|
|
611
|
-
const changed = createItem("Changed", expression.subscript, scope, undefined);
|
|
612
|
-
visit(replay, expression.action, changed, scope, getEmptyState(environment));
|
|
816
|
+
const changed = createItem("Changed", expression.subscript, scope, -1, undefined);
|
|
817
|
+
visit(replay, expression.action, changed, scope, getEmptyState(environment), -1);
|
|
613
818
|
} else {
|
|
614
|
-
visit(replay, expression, undefined, scope, getEmptyState(environment));
|
|
819
|
+
visit(replay, expression, undefined, scope, getEmptyState(environment), -1);
|
|
615
820
|
}
|
|
616
821
|
return false;
|
|
617
822
|
} catch (error) {
|
|
618
823
|
if (error !== ENABLED_FOUND) throw error;
|
|
619
|
-
|
|
620
|
-
|
|
621
|
-
|
|
824
|
+
if (callStack) {
|
|
825
|
+
callStack.expressions.length = depth;
|
|
826
|
+
callStack.isFrozen = false;
|
|
827
|
+
}
|
|
622
828
|
return true;
|
|
623
829
|
}
|
|
624
830
|
};
|
|
625
831
|
|
|
626
|
-
// TLC's getInitStates, which conjoins the initial predicates of the specification.
|
|
627
832
|
export const replayInitialStates = (
|
|
628
|
-
inits: ReplayAction[],
|
|
833
|
+
inits: (ReplayAction & { node?: number })[],
|
|
629
834
|
environment: Environment,
|
|
630
835
|
onState: (state: Value[]) => void,
|
|
836
|
+
onIncomplete?: (state: State) => void,
|
|
631
837
|
) => {
|
|
632
838
|
const [first, ...others] = inits;
|
|
633
839
|
if (first === undefined) return;
|
|
634
|
-
const replay = createReplay(environment, true, undefined, onState);
|
|
840
|
+
const replay = createReplay(environment, true, undefined, onState, false, onIncomplete);
|
|
635
841
|
const rest = others.reduceRight<ActionItem | undefined>(
|
|
636
|
-
(tail, init) => createItem("Predicate", init.expression, init.scope, tail),
|
|
842
|
+
(tail, init) => createItem("Predicate", init.expression, init.scope, init.node ?? -1, tail),
|
|
637
843
|
undefined,
|
|
638
844
|
);
|
|
639
|
-
visit(replay, first.expression, rest, first.scope, getEmptyState(environment));
|
|
845
|
+
visit(replay, first.expression, rest, first.scope, getEmptyState(environment), first.node ?? -1);
|
|
640
846
|
};
|
|
641
847
|
|
|
642
|
-
// TLC's getNextStates for each action TLC splits the next-state relation into. TLC checks the
|
|
643
|
-
// successors of an action once it has computed them all.
|
|
644
848
|
export const replaySuccessors = <Action extends ReplayAction>(
|
|
645
849
|
actions: Action[],
|
|
646
850
|
state: Value[],
|
|
647
851
|
environment: Environment,
|
|
648
852
|
onState: (state: Value[], action: Action) => void,
|
|
649
853
|
) => {
|
|
650
|
-
// TLC fails to split a next-state relation that is not an operator application before it checks
|
|
651
|
-
// the spec, so it replays nothing.
|
|
652
854
|
if (actions.some((action) => LITERAL_KINDS.has(action.expression.kind))) return;
|
|
653
855
|
actions.forEach((action) => {
|
|
654
856
|
const successors: Value[][] = [];
|
|
655
|
-
|
|
656
|
-
visit(replay, action.expression, undefined, action.scope, getEmptyState(environment));
|
|
857
|
+
walkSuccessors(action, -1, state, environment, (next) => successors.push(next));
|
|
657
858
|
successors.forEach((successor) => onState(successor, action));
|
|
658
859
|
});
|
|
659
860
|
};
|
|
861
|
+
|
|
862
|
+
export const walkSuccessors = (
|
|
863
|
+
action: ReplayAction,
|
|
864
|
+
node: number,
|
|
865
|
+
state: Value[],
|
|
866
|
+
environment: Environment,
|
|
867
|
+
onState: (state: Value[]) => void,
|
|
868
|
+
onIncomplete?: (state: State) => void,
|
|
869
|
+
) => {
|
|
870
|
+
const replay = createReplay(environment, false, state, onState, false, onIncomplete);
|
|
871
|
+
visit(replay, action.expression, undefined, action.scope, getEmptyState(environment), node);
|
|
872
|
+
};
|
|
873
|
+
|
|
874
|
+
export const getPrimedRanges = (actions: ReplayAction[], environment: Environment) => {
|
|
875
|
+
const ranges: Expression[] = [];
|
|
876
|
+
const createContext = (scope: Scope | undefined): Context => ({
|
|
877
|
+
environment,
|
|
878
|
+
scope,
|
|
879
|
+
state: undefined,
|
|
880
|
+
next: undefined,
|
|
881
|
+
});
|
|
882
|
+
const collectUnchanged = (expression: Expression, scope: Scope | undefined): void => {
|
|
883
|
+
if (
|
|
884
|
+
getVariable(environment, expression, undefined) !== undefined &&
|
|
885
|
+
expression.kind === "Identifier"
|
|
886
|
+
) {
|
|
887
|
+
ranges.push(expression);
|
|
888
|
+
return;
|
|
889
|
+
}
|
|
890
|
+
if (expression.kind === "Tuple") {
|
|
891
|
+
expression.elements.forEach((element) => collectUnchanged(element, scope));
|
|
892
|
+
return;
|
|
893
|
+
}
|
|
894
|
+
if (expression.kind !== "Identifier") return;
|
|
895
|
+
const binding = lookupScope(scope, expression.name);
|
|
896
|
+
const operator = binding ? undefined : resolveGlobalOperator(expression.name, environment);
|
|
897
|
+
if (operator?.kind === "Closure" && operator.params.length === 0) {
|
|
898
|
+
collectUnchanged(operator.body, operator.scope);
|
|
899
|
+
}
|
|
900
|
+
};
|
|
901
|
+
const collect = (
|
|
902
|
+
expression: Expression,
|
|
903
|
+
scope: Scope | undefined,
|
|
904
|
+
visited: Set<Expression>,
|
|
905
|
+
): void => {
|
|
906
|
+
switch (expression.kind) {
|
|
907
|
+
case "Let":
|
|
908
|
+
collect(
|
|
909
|
+
expression.body,
|
|
910
|
+
bindDefinitions(expression.definitions, createContext(scope)),
|
|
911
|
+
visited,
|
|
912
|
+
);
|
|
913
|
+
return;
|
|
914
|
+
case "Label":
|
|
915
|
+
collect(expression.body, scope, visited);
|
|
916
|
+
return;
|
|
917
|
+
case "FunctionApplication":
|
|
918
|
+
collect(expression.function, scope, visited);
|
|
919
|
+
return;
|
|
920
|
+
case "If":
|
|
921
|
+
collect(expression.consequent, scope, visited);
|
|
922
|
+
collect(expression.alternative, scope, visited);
|
|
923
|
+
return;
|
|
924
|
+
case "Case":
|
|
925
|
+
expression.arms.forEach((arm) => collect(arm.body, scope, visited));
|
|
926
|
+
if (expression.other) collect(expression.other, scope, visited);
|
|
927
|
+
return;
|
|
928
|
+
case "And":
|
|
929
|
+
case "Or":
|
|
930
|
+
expression.operands.forEach((operand) => collect(operand, scope, visited));
|
|
931
|
+
return;
|
|
932
|
+
case "Exists":
|
|
933
|
+
case "Forall":
|
|
934
|
+
collect(expression.body, scope, visited);
|
|
935
|
+
return;
|
|
936
|
+
case "Unchanged":
|
|
937
|
+
collectUnchanged(expression.expression, scope);
|
|
938
|
+
return;
|
|
939
|
+
case "AngleAction":
|
|
940
|
+
collect(expression.action, scope, visited);
|
|
941
|
+
return;
|
|
942
|
+
case "BoxAction":
|
|
943
|
+
collect(expression.action, scope, visited);
|
|
944
|
+
ranges.push(expression.subscript);
|
|
945
|
+
return;
|
|
946
|
+
case "Identifier":
|
|
947
|
+
case "Apply": {
|
|
948
|
+
if (expression.kind === "Apply") {
|
|
949
|
+
if (expression.operator === "=>") {
|
|
950
|
+
expression.args.forEach((arg) => collect(arg, scope, visited));
|
|
951
|
+
return;
|
|
952
|
+
}
|
|
953
|
+
if (expression.operator === "=" || expression.operator === "\\in") {
|
|
954
|
+
if (getPrimedVariable(environment, expression.args[0], scope) !== undefined) {
|
|
955
|
+
ranges.push(expression);
|
|
956
|
+
}
|
|
957
|
+
return;
|
|
958
|
+
}
|
|
959
|
+
}
|
|
960
|
+
const name = expression.kind === "Identifier" ? expression.name : expression.operator;
|
|
961
|
+
const binding = lookupScope(scope, name);
|
|
962
|
+
if (binding?.kind === "Thunk") {
|
|
963
|
+
collect(binding.expression, binding.scope, visited);
|
|
964
|
+
return;
|
|
965
|
+
}
|
|
966
|
+
const operator =
|
|
967
|
+
expression.kind === "Apply"
|
|
968
|
+
? resolveApplyOperator(expression, createContext(scope))
|
|
969
|
+
: binding?.kind === "Operator"
|
|
970
|
+
? binding.operator
|
|
971
|
+
: binding
|
|
972
|
+
? undefined
|
|
973
|
+
: resolveGlobalOperator(name, environment);
|
|
974
|
+
if (operator?.kind !== "Closure" || visited.has(operator.body)) return;
|
|
975
|
+
const definition = environment.definitions.get(name);
|
|
976
|
+
if (definition?.isRecursive) return;
|
|
977
|
+
const args = expression.kind === "Apply" ? expression.args : [];
|
|
978
|
+
if (operator.params.length !== args.length) return;
|
|
979
|
+
visited.add(operator.body);
|
|
980
|
+
collect(
|
|
981
|
+
operator.body,
|
|
982
|
+
bindOperatorArguments(operator, args, createContext(scope)),
|
|
983
|
+
visited,
|
|
984
|
+
);
|
|
985
|
+
visited.delete(operator.body);
|
|
986
|
+
}
|
|
987
|
+
}
|
|
988
|
+
};
|
|
989
|
+
actions.forEach((action) => collect(action.expression, action.scope, new Set()));
|
|
990
|
+
return ranges.flatMap((expression) => expression.location.range ?? []);
|
|
991
|
+
};
|