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/successors.ts
CHANGED
|
@@ -7,7 +7,12 @@ import {
|
|
|
7
7
|
} from "./ast";
|
|
8
8
|
import { getKindString } from "./builtins";
|
|
9
9
|
import { getReadVariables } from "./dependencies";
|
|
10
|
-
import {
|
|
10
|
+
import {
|
|
11
|
+
TlaEvaluationError,
|
|
12
|
+
TlaIllegalStateError,
|
|
13
|
+
TlaIncompleteSuccessorError,
|
|
14
|
+
TlaUncodedError,
|
|
15
|
+
} from "./errors";
|
|
11
16
|
import { EXIT_STATUS, setExitCode } from "./exit-codes";
|
|
12
17
|
import {
|
|
13
18
|
describeLocation,
|
|
@@ -16,10 +21,10 @@ import {
|
|
|
16
21
|
bindLazyArguments,
|
|
17
22
|
bindDefinitions,
|
|
18
23
|
bindOperatorArguments,
|
|
24
|
+
bindPattern,
|
|
19
25
|
bindValue,
|
|
20
26
|
compileArgumentScope,
|
|
21
27
|
evaluate,
|
|
22
|
-
expectBoolean,
|
|
23
28
|
forEachBinding,
|
|
24
29
|
getLazyFunction,
|
|
25
30
|
toKeepLazyContext,
|
|
@@ -27,7 +32,9 @@ import {
|
|
|
27
32
|
getContextElements,
|
|
28
33
|
getEntryEvaluator,
|
|
29
34
|
getReevaluatedDefinitions,
|
|
35
|
+
getStartupValue,
|
|
30
36
|
lookupScope,
|
|
37
|
+
mapBoundSets,
|
|
31
38
|
resolveApplyOperator,
|
|
32
39
|
resolveGlobalOperator,
|
|
33
40
|
toUnspecifiedSubscriptError,
|
|
@@ -38,13 +45,21 @@ import {
|
|
|
38
45
|
type State,
|
|
39
46
|
} from "./evaluate";
|
|
40
47
|
import { mapChildren } from "./instances";
|
|
41
|
-
import {
|
|
48
|
+
import { CORE_OPERATORS } from "./standard-modules";
|
|
49
|
+
import { getRandomSubset, nextPrime, type JavaRandom } from "./tlc/random";
|
|
50
|
+
import {
|
|
51
|
+
getEnabledFailure,
|
|
52
|
+
isAssignedShortcut,
|
|
53
|
+
LITERAL_KINDS,
|
|
54
|
+
replayEnabled,
|
|
55
|
+
warnChangedUnchanged,
|
|
56
|
+
} from "./tlc/replay";
|
|
42
57
|
import {
|
|
43
58
|
formatValue,
|
|
44
59
|
getStreamedElements,
|
|
60
|
+
isEqualLikeTlc,
|
|
45
61
|
isFunctionValue,
|
|
46
62
|
isTlcEnumerable,
|
|
47
|
-
valuesEqual,
|
|
48
63
|
type Value,
|
|
49
64
|
} from "./values";
|
|
50
65
|
|
|
@@ -56,10 +71,12 @@ export interface Successor {
|
|
|
56
71
|
interface Run {
|
|
57
72
|
environment: Environment;
|
|
58
73
|
isInit: boolean;
|
|
59
|
-
// Whether the run computes ENABLED rather than the successors of the state.
|
|
60
74
|
isEnabled: boolean;
|
|
61
75
|
current: Value[] | undefined;
|
|
62
76
|
isStopped: boolean;
|
|
77
|
+
generator: JavaRandom | undefined;
|
|
78
|
+
successors: number;
|
|
79
|
+
onUnsatisfied?: (state: Value[], conjunct: Expression) => void;
|
|
63
80
|
}
|
|
64
81
|
|
|
65
82
|
type Continuation = (partial: State, action: string | undefined) => void;
|
|
@@ -76,7 +93,7 @@ type Runner = (
|
|
|
76
93
|
type Conjunct = { expression: Expression } & (
|
|
77
94
|
| { kind: "Guard" }
|
|
78
95
|
| { kind: "Assign"; index: number; value: Expression }
|
|
79
|
-
| { kind: "Unchanged";
|
|
96
|
+
| { kind: "Unchanged"; variables: UnchangedVariable[] }
|
|
80
97
|
| { kind: "Branch"; runner: Runner }
|
|
81
98
|
);
|
|
82
99
|
|
|
@@ -94,18 +111,14 @@ const assign = (partial: State, index: number, value: Value) => {
|
|
|
94
111
|
return copy;
|
|
95
112
|
};
|
|
96
113
|
|
|
97
|
-
// What TLC says it was computing when it fails.
|
|
98
114
|
const getComputation = (run: Run) =>
|
|
99
115
|
run.isInit ? "initial states" : run.isEnabled ? "ENABLED" : "next states";
|
|
100
116
|
|
|
101
|
-
// TLC fails with an unexpected exception when it fails to compute the next states or ENABLED.
|
|
102
117
|
const createRunError = (run: Run, message: string) => {
|
|
103
118
|
const error = new TlaEvaluationError(message);
|
|
104
119
|
return run.isInit ? error : setExitCode(error, EXIT_STATUS.error);
|
|
105
120
|
};
|
|
106
121
|
|
|
107
|
-
// TLC's message for a conjunct that isn't a boolean, which differs for a literal it walks to rather
|
|
108
|
-
// than evaluates.
|
|
109
122
|
const getNonBooleanMessage = (
|
|
110
123
|
run: Run,
|
|
111
124
|
value: Value,
|
|
@@ -121,7 +134,6 @@ const getNonBooleanMessage = (
|
|
|
121
134
|
return `In computing ${getComputation(run)}, TLC expected a boolean expression,\nbut instead found ${formatValue(value)}.\n${node}`;
|
|
122
135
|
};
|
|
123
136
|
|
|
124
|
-
// TLC words an IF whose condition isn't a boolean differently for each computation.
|
|
125
137
|
const getIfConditionMessage = (run: Run, value: Value, expression: Expression) => {
|
|
126
138
|
const kind = getKindString(value);
|
|
127
139
|
const range = describeRange(expression);
|
|
@@ -134,9 +146,19 @@ const getIfConditionMessage = (run: Run, value: Value, expression: Expression) =
|
|
|
134
146
|
const holds = (run: Run, expression: Expression, context: Context) =>
|
|
135
147
|
holdsValue(run, expression, evaluate(expression, context));
|
|
136
148
|
|
|
149
|
+
const CORE_OPERATOR_NAMES = new Set(CORE_OPERATORS.map((operator) => operator.name));
|
|
150
|
+
|
|
151
|
+
const isBuiltInOperation = (expression: Expression) =>
|
|
152
|
+
expression.kind === "Apply"
|
|
153
|
+
? CORE_OPERATOR_NAMES.has(expression.operator)
|
|
154
|
+
: expression.kind !== "Identifier" && !LITERAL_KINDS.has(expression.kind);
|
|
155
|
+
|
|
137
156
|
const holdsValue = (run: Run, expression: Expression, value: Value, isWalked = true) => {
|
|
138
157
|
if (typeof value === "boolean") return value;
|
|
139
|
-
|
|
158
|
+
const message = getNonBooleanMessage(run, value, expression, isWalked);
|
|
159
|
+
throw run.isInit && isWalked && isBuiltInOperation(expression)
|
|
160
|
+
? new TlaUncodedError(message)
|
|
161
|
+
: createRunError(run, message);
|
|
140
162
|
};
|
|
141
163
|
|
|
142
164
|
const evaluateCached = (
|
|
@@ -156,7 +178,12 @@ const getRunner = (expression: Expression, environment: Environment, isInit: boo
|
|
|
156
178
|
const runners = isInit ? initRunners : nextRunners;
|
|
157
179
|
const cached = runners.get(expression);
|
|
158
180
|
if (cached) return cached;
|
|
159
|
-
const
|
|
181
|
+
const deterministic = compileAction(expression, environment, isInit);
|
|
182
|
+
const random = isInit ? undefined : compileRandomAction(expression, environment);
|
|
183
|
+
const runner: Runner = random
|
|
184
|
+
? (run, scope, partial, action, isFixed, onComplete) =>
|
|
185
|
+
(run.generator ? random : deterministic)(run, scope, partial, action, isFixed, onComplete)
|
|
186
|
+
: deterministic;
|
|
160
187
|
runners.set(expression, runner);
|
|
161
188
|
return runner;
|
|
162
189
|
};
|
|
@@ -204,7 +231,7 @@ const getRuntimeVariableIndex = (
|
|
|
204
231
|
}
|
|
205
232
|
if (expression.kind !== "Identifier") return undefined;
|
|
206
233
|
const binding = lookupScope(scope, expression.name);
|
|
207
|
-
if (binding?.kind === "Thunk") {
|
|
234
|
+
if (binding?.kind === "Thunk" && !binding.isReleased) {
|
|
208
235
|
return getRuntimeVariableIndex(binding.expression, binding.scope, partial, run, isPrimed);
|
|
209
236
|
}
|
|
210
237
|
if (binding) return undefined;
|
|
@@ -220,24 +247,29 @@ const isPossiblyAssignable = (target: Expression, isInit: boolean) =>
|
|
|
220
247
|
(target.kind === "Identifier" && (isInit || isLocallyResolved(target))) ||
|
|
221
248
|
(!isInit && target.kind === "Prime");
|
|
222
249
|
|
|
223
|
-
|
|
250
|
+
interface UnchangedVariable {
|
|
251
|
+
index: number;
|
|
252
|
+
expression: Expression;
|
|
253
|
+
}
|
|
254
|
+
|
|
255
|
+
const getUnchangedVariables = (
|
|
224
256
|
expression: Expression,
|
|
225
257
|
environment: Environment,
|
|
226
258
|
visited = new Set<string>(),
|
|
227
|
-
):
|
|
259
|
+
): UnchangedVariable[] | undefined => {
|
|
228
260
|
if (expression.kind === "Tuple") {
|
|
229
|
-
const
|
|
230
|
-
|
|
261
|
+
const variables = expression.elements.map((element) =>
|
|
262
|
+
getUnchangedVariables(element, environment, visited),
|
|
231
263
|
);
|
|
232
|
-
return
|
|
264
|
+
return variables.every((item) => item !== undefined) ? variables.flat() : undefined;
|
|
233
265
|
}
|
|
234
266
|
if (expression.kind !== "Identifier" || visited.has(expression.name)) return undefined;
|
|
235
267
|
const index = environment.variableIndex.get(expression.name);
|
|
236
|
-
if (index !== undefined) return [index];
|
|
268
|
+
if (index !== undefined) return [{ index, expression }];
|
|
237
269
|
const definition = getZeroArityBody(expression.name, environment);
|
|
238
270
|
if (!definition) return undefined;
|
|
239
271
|
visited.add(expression.name);
|
|
240
|
-
return
|
|
272
|
+
return getUnchangedVariables(definition.body, environment, visited);
|
|
241
273
|
};
|
|
242
274
|
|
|
243
275
|
const ACTION_KINDS = new Set([
|
|
@@ -277,9 +309,7 @@ const isGuard = (expression: Expression, environment: Environment, isInit: boole
|
|
|
277
309
|
|
|
278
310
|
const NO_NAMES: ReadonlySet<string> = new Set();
|
|
279
311
|
|
|
280
|
-
|
|
281
|
-
// operator, whose body may assign variables.
|
|
282
|
-
export const getReadLocals = (
|
|
312
|
+
const getReadLocals = (
|
|
283
313
|
expression: Expression,
|
|
284
314
|
bound: ReadonlySet<string>,
|
|
285
315
|
): string[] | undefined => {
|
|
@@ -288,20 +318,18 @@ export const getReadLocals = (
|
|
|
288
318
|
return bound.has(expression.name) ? [] : [expression.name];
|
|
289
319
|
}
|
|
290
320
|
const names: string[] = [];
|
|
291
|
-
|
|
321
|
+
let isReadOnly = true;
|
|
292
322
|
mapChildren(expression, (child, childNames) => {
|
|
293
|
-
const childLocals =
|
|
323
|
+
const childLocals = isReadOnly
|
|
294
324
|
? getReadLocals(child, childNames.length === 0 ? bound : new Set([...bound, ...childNames]))
|
|
295
325
|
: [];
|
|
296
326
|
if (childLocals) names.push(...childLocals);
|
|
297
|
-
else
|
|
327
|
+
else isReadOnly = false;
|
|
298
328
|
return child;
|
|
299
329
|
});
|
|
300
|
-
return
|
|
330
|
+
return isReadOnly ? names : undefined;
|
|
301
331
|
};
|
|
302
332
|
|
|
303
|
-
// TLC generates a successor for every disjunct and witness that holds, so an expression only
|
|
304
|
-
// checks like a guard when it has neither.
|
|
305
333
|
const hasBranches = (
|
|
306
334
|
expression: Expression,
|
|
307
335
|
environment: Environment,
|
|
@@ -337,15 +365,13 @@ const toConjunct = (
|
|
|
337
365
|
}
|
|
338
366
|
}
|
|
339
367
|
if (!isInit && expression.kind === "Unchanged") {
|
|
340
|
-
const
|
|
341
|
-
if (
|
|
368
|
+
const variables = getUnchangedVariables(expression.expression, environment);
|
|
369
|
+
if (variables) return { kind: "Unchanged", expression, variables };
|
|
342
370
|
}
|
|
343
371
|
if (isGuard(expression, environment, isInit)) return { kind: "Guard", expression };
|
|
344
372
|
return { kind: "Branch", expression, runner: getRunner(expression, environment, isInit) };
|
|
345
373
|
};
|
|
346
374
|
|
|
347
|
-
// The leading guards of `\E x \in S, y \in T : P /\ Q` that read no inner bound hold for every inner
|
|
348
|
-
// binding alike, so they can run once for each element of the outermost bound.
|
|
349
375
|
const getHoistedGuards = (expression: QuantifierExpression, environment: Environment) => {
|
|
350
376
|
if (expression.bounds.length < 2 || expression.body.kind !== "And") return undefined;
|
|
351
377
|
const names = expression.bounds.flatMap((bound) =>
|
|
@@ -388,9 +414,25 @@ const compileConjunction = (
|
|
|
388
414
|
if (index > 0 && isShortcut && isComplete(current)) {
|
|
389
415
|
context ??= getContext(run, scope, current);
|
|
390
416
|
for (let rest = index; rest < conjuncts.length; rest++) {
|
|
391
|
-
const
|
|
417
|
+
const conjunct = conjuncts[rest];
|
|
418
|
+
const state = run.current;
|
|
419
|
+
const changed =
|
|
420
|
+
state && conjunct.kind === "Unchanged"
|
|
421
|
+
? conjunct.variables.find((variable) => {
|
|
422
|
+
const assigned = current[variable.index];
|
|
423
|
+
return assigned !== undefined && !isEqualLikeTlc(assigned, state[variable.index]);
|
|
424
|
+
})
|
|
425
|
+
: undefined;
|
|
426
|
+
if (changed) {
|
|
427
|
+
warnChangedUnchanged(run.environment, changed.index, changed.expression);
|
|
428
|
+
return;
|
|
429
|
+
}
|
|
430
|
+
const expression = conjunct.expression;
|
|
392
431
|
const value = evaluateCached(restEvaluators, rest, expression, context);
|
|
393
|
-
if (!holdsValue(run, expression, value, false))
|
|
432
|
+
if (!holdsValue(run, expression, value, false)) {
|
|
433
|
+
run.onUnsatisfied?.(current, expression);
|
|
434
|
+
return;
|
|
435
|
+
}
|
|
394
436
|
}
|
|
395
437
|
onComplete(current, action);
|
|
396
438
|
return;
|
|
@@ -409,7 +451,7 @@ const compileConjunction = (
|
|
|
409
451
|
if (assigned === undefined) {
|
|
410
452
|
current = assign(current, conjunct.index, value);
|
|
411
453
|
context = undefined;
|
|
412
|
-
} else if (!
|
|
454
|
+
} else if (!isEqualLikeTlc(assigned, value)) {
|
|
413
455
|
return;
|
|
414
456
|
}
|
|
415
457
|
continue;
|
|
@@ -418,12 +460,13 @@ const compileConjunction = (
|
|
|
418
460
|
const state = run.current;
|
|
419
461
|
if (!state) return;
|
|
420
462
|
let unchanged: State | undefined;
|
|
421
|
-
for (const variable of conjunct.
|
|
422
|
-
const assigned = (unchanged ?? current)[variable];
|
|
463
|
+
for (const variable of conjunct.variables) {
|
|
464
|
+
const assigned = (unchanged ?? current)[variable.index];
|
|
423
465
|
if (assigned === undefined) {
|
|
424
466
|
unchanged ??= current.slice();
|
|
425
|
-
unchanged[variable] = state[variable];
|
|
426
|
-
} else if (!
|
|
467
|
+
unchanged[variable.index] = state[variable.index];
|
|
468
|
+
} else if (!isEqualLikeTlc(assigned, state[variable.index])) {
|
|
469
|
+
warnChangedUnchanged(run.environment, variable.index, variable.expression);
|
|
427
470
|
return;
|
|
428
471
|
}
|
|
429
472
|
}
|
|
@@ -445,11 +488,13 @@ const compileConjunction = (
|
|
|
445
488
|
runFrom(0, run, scope, partial, action, onComplete);
|
|
446
489
|
};
|
|
447
490
|
|
|
448
|
-
const compileGuard =
|
|
449
|
-
(expression
|
|
450
|
-
(run, scope, partial, action, _isFixed, onComplete) => {
|
|
491
|
+
const compileGuard = (expression: Expression): Runner => {
|
|
492
|
+
const enabledFailure = getEnabledFailure(expression);
|
|
493
|
+
return (run, scope, partial, action, _isFixed, onComplete) => {
|
|
494
|
+
if (run.isEnabled && enabledFailure !== undefined) throw createRunError(run, enabledFailure);
|
|
451
495
|
if (holds(run, expression, getContext(run, scope, partial))) onComplete(partial, action);
|
|
452
496
|
};
|
|
497
|
+
};
|
|
453
498
|
|
|
454
499
|
const compileMembership = (
|
|
455
500
|
expression: Expression & { kind: "Apply" },
|
|
@@ -473,6 +518,17 @@ const compileMembership = (
|
|
|
473
518
|
throw createRunError(run, `${message}\n${describeRange(expression)}`);
|
|
474
519
|
}
|
|
475
520
|
const elements = getStreamedElements(value);
|
|
521
|
+
if (run.generator) {
|
|
522
|
+
for (const element of getRandomSubset(
|
|
523
|
+
elements.length,
|
|
524
|
+
value,
|
|
525
|
+
run.environment.runtime.getRandom(),
|
|
526
|
+
run.environment.runtime.version,
|
|
527
|
+
)) {
|
|
528
|
+
onComplete(assign(partial, index, element), action);
|
|
529
|
+
if (run.successors > 0 || run.isStopped) return;
|
|
530
|
+
}
|
|
531
|
+
}
|
|
476
532
|
for (let position = 0; position < elements.length && !run.isStopped; position++) {
|
|
477
533
|
onComplete(assign(partial, index, elements[position]), action);
|
|
478
534
|
}
|
|
@@ -520,8 +576,6 @@ const compileDynamicAssignment = (
|
|
|
520
576
|
};
|
|
521
577
|
};
|
|
522
578
|
|
|
523
|
-
// Tool.getInitStates and Tool.getNextStates walk the body of a function they apply that is still
|
|
524
|
-
// lazy, which they evaluate as TLC computes the initial states eagerly, and otherwise apply it.
|
|
525
579
|
const compileFunctionAction = (
|
|
526
580
|
expression: Expression & { kind: "FunctionApplication" },
|
|
527
581
|
environment: Environment,
|
|
@@ -561,15 +615,15 @@ const compileFunctionAction = (
|
|
|
561
615
|
};
|
|
562
616
|
|
|
563
617
|
const compileUnchanged = (expression: Expression, environment: Environment): Runner => {
|
|
564
|
-
|
|
565
|
-
|
|
618
|
+
if (getUnchangedVariables(expression, environment))
|
|
619
|
+
return compileConjunction([getUnchangedWrapper(expression)], environment, false);
|
|
566
620
|
if (expression.kind === "Tuple")
|
|
567
621
|
return getRunner(getUnchangedWrapper(expression), environment, false);
|
|
568
622
|
const unchanged = getUnchangedWrapper(expression);
|
|
569
623
|
return (run, scope, partial, action, isFixed, onComplete) => {
|
|
570
624
|
const binding =
|
|
571
625
|
expression.kind === "Identifier" ? lookupScope(scope, expression.name) : undefined;
|
|
572
|
-
if (binding?.kind === "Thunk") {
|
|
626
|
+
if (binding?.kind === "Thunk" && !binding.isReleased) {
|
|
573
627
|
getRunner(getUnchangedWrapper(binding.expression), environment, false)(
|
|
574
628
|
run,
|
|
575
629
|
binding.scope,
|
|
@@ -580,7 +634,22 @@ const compileUnchanged = (expression: Expression, environment: Environment): Run
|
|
|
580
634
|
);
|
|
581
635
|
return;
|
|
582
636
|
}
|
|
583
|
-
|
|
637
|
+
const context = getContext(run, scope, partial);
|
|
638
|
+
if (run.isEnabled && expression.kind === "Apply") {
|
|
639
|
+
const operator = resolveApplyOperator(expression, context);
|
|
640
|
+
if (operator?.kind === "Closure" && operator.params.length === expression.args.length) {
|
|
641
|
+
getRunner(getUnchangedWrapper(operator.body), environment, false)(
|
|
642
|
+
run,
|
|
643
|
+
bindOperatorArguments(operator, expression.args, context),
|
|
644
|
+
partial,
|
|
645
|
+
action,
|
|
646
|
+
isFixed,
|
|
647
|
+
onComplete,
|
|
648
|
+
);
|
|
649
|
+
return;
|
|
650
|
+
}
|
|
651
|
+
}
|
|
652
|
+
if (holds(run, unchanged, context)) onComplete(partial, action);
|
|
584
653
|
};
|
|
585
654
|
};
|
|
586
655
|
|
|
@@ -597,10 +666,10 @@ const compileCall = (
|
|
|
597
666
|
if (global?.kind === "Builtin") return guard;
|
|
598
667
|
if (global?.kind === "Closure") {
|
|
599
668
|
const bindArguments = compileArgumentScope(global, expression.args, environment);
|
|
600
|
-
|
|
669
|
+
let bodyRunner: Runner | undefined;
|
|
601
670
|
return (run, scope, partial, action, isFixed, onComplete) => {
|
|
602
|
-
|
|
603
|
-
|
|
671
|
+
bodyRunner ??= getRunner(global.body, environment, isInit);
|
|
672
|
+
bodyRunner(
|
|
604
673
|
run,
|
|
605
674
|
bindArguments(getContext(run, scope, partial)),
|
|
606
675
|
partial,
|
|
@@ -637,10 +706,10 @@ const compileIdentifier = (
|
|
|
637
706
|
const definition = isLocallyResolved(expression)
|
|
638
707
|
? undefined
|
|
639
708
|
: getZeroArityBody(expression.name, environment);
|
|
640
|
-
|
|
709
|
+
let bodyRunner: Runner | undefined;
|
|
641
710
|
return (run, scope, partial, action, isFixed, onComplete) => {
|
|
642
711
|
const binding = lookupScope(scope, expression.name);
|
|
643
|
-
if (binding?.kind === "Thunk") {
|
|
712
|
+
if (binding?.kind === "Thunk" && !binding.isReleased) {
|
|
644
713
|
getRunner(binding.expression, environment, isInit)(
|
|
645
714
|
run,
|
|
646
715
|
binding.scope,
|
|
@@ -651,20 +720,19 @@ const compileIdentifier = (
|
|
|
651
720
|
);
|
|
652
721
|
return;
|
|
653
722
|
}
|
|
654
|
-
if (
|
|
723
|
+
if (
|
|
724
|
+
binding ||
|
|
725
|
+
!definition ||
|
|
726
|
+
(expression.location.range && getStartupValue(definition, environment) !== undefined)
|
|
727
|
+
) {
|
|
655
728
|
guard(run, scope, partial, action, isFixed, onComplete);
|
|
656
729
|
return;
|
|
657
730
|
}
|
|
658
|
-
|
|
659
|
-
|
|
731
|
+
bodyRunner ??= getRunner(definition.body, environment, isInit);
|
|
732
|
+
bodyRunner(run, undefined, partial, isFixed ? action : definition.name, isFixed, onComplete);
|
|
660
733
|
};
|
|
661
734
|
};
|
|
662
735
|
|
|
663
|
-
// A PlusCal action starts with a guard such as pc[self] = "L1", and a process is a disjunction of
|
|
664
|
-
// its actions. The labels an expression requires of one variable at one bound name let a
|
|
665
|
-
// disjunction skip the operands whose guard is false without evaluating them. A hand-written
|
|
666
|
-
// action often puts other guards first, such as running = self /\ pc[self] = "L1". TLC evaluates
|
|
667
|
-
// those before the label's guard, so a skipped operand still runs them, for their errors.
|
|
668
736
|
interface LabelGuard {
|
|
669
737
|
variable: number;
|
|
670
738
|
argument: string;
|
|
@@ -689,16 +757,12 @@ const toLabelGuard = (expression: Expression, environment: Environment) => {
|
|
|
689
757
|
const getConjuncts = (expression: Expression): Expression[] =>
|
|
690
758
|
expression.kind === "And" ? expression.operands.flatMap(getConjuncts) : [expression];
|
|
691
759
|
|
|
692
|
-
// What may come before the label's guard: a comparison or a name that a conjunction checks as a
|
|
693
|
-
// guard. An operand with another conjunct first, such as an assignment or a name defined as an
|
|
694
|
-
// action that may branch, runs in full.
|
|
695
760
|
const isLeadingGuard = (expression: Expression, environment: Environment) =>
|
|
696
761
|
(expression.kind === "Identifier" ||
|
|
697
762
|
(expression.kind === "Apply" &&
|
|
698
763
|
(expression.operator === "=" || expression.operator === "#"))) &&
|
|
699
764
|
isGuard(expression, environment, false);
|
|
700
765
|
|
|
701
|
-
// Checks the guards before a label's guard as a conjunction does, for TLC's errors.
|
|
702
766
|
const compileLeadingGuards = (guards: Expression[]) => {
|
|
703
767
|
const evaluators: (Evaluator | undefined)[] = [];
|
|
704
768
|
return (run: Run, scope: Scope | undefined, partial: State) => {
|
|
@@ -813,6 +877,66 @@ const compileDisjunction = (
|
|
|
813
877
|
};
|
|
814
878
|
};
|
|
815
879
|
|
|
880
|
+
const compileRandomChoice =
|
|
881
|
+
(choices: Runner[]): Runner =>
|
|
882
|
+
(run, scope, partial, action, isFixed, onComplete) => {
|
|
883
|
+
const generator = run.generator;
|
|
884
|
+
if (!generator) throw new Error("A random choice needs the run's generator");
|
|
885
|
+
const start = Math.floor(generator.nextDouble() * choices.length);
|
|
886
|
+
const prime = nextPrime(generator);
|
|
887
|
+
for (let attempt = 0; attempt < choices.length; attempt++) {
|
|
888
|
+
choices[(start + attempt * prime) % choices.length](
|
|
889
|
+
run,
|
|
890
|
+
scope,
|
|
891
|
+
partial,
|
|
892
|
+
action,
|
|
893
|
+
isFixed,
|
|
894
|
+
onComplete,
|
|
895
|
+
);
|
|
896
|
+
if (run.successors > 0 || run.isStopped) return;
|
|
897
|
+
}
|
|
898
|
+
};
|
|
899
|
+
|
|
900
|
+
const compileRandomExists = (
|
|
901
|
+
expression: QuantifierExpression,
|
|
902
|
+
environment: Environment,
|
|
903
|
+
): Runner => {
|
|
904
|
+
const body = getRunner(expression.body, environment, false);
|
|
905
|
+
return (run, scope, partial, action, isFixed, onComplete) => {
|
|
906
|
+
const context = getContext(run, scope, partial);
|
|
907
|
+
const version = environment.runtime.version;
|
|
908
|
+
const orders = mapBoundSets(expression.bounds, (set) => evaluate(set, context)).map(
|
|
909
|
+
(set, index) =>
|
|
910
|
+
getRandomSubset(
|
|
911
|
+
getContextElements(set, expression.bounds[index].set, version).length,
|
|
912
|
+
set,
|
|
913
|
+
environment.runtime.getRandom(),
|
|
914
|
+
version,
|
|
915
|
+
),
|
|
916
|
+
);
|
|
917
|
+
const visit = (position: number, boundScope: Scope | undefined): boolean => {
|
|
918
|
+
if (position < 0) {
|
|
919
|
+
body(run, boundScope, partial, action, isFixed, onComplete);
|
|
920
|
+
return run.successors > 0 || run.isStopped;
|
|
921
|
+
}
|
|
922
|
+
const pattern = expression.bounds[position].pattern;
|
|
923
|
+
return orders[position].some((element) =>
|
|
924
|
+
visit(position - 1, bindPattern(boundScope, pattern, element)),
|
|
925
|
+
);
|
|
926
|
+
};
|
|
927
|
+
visit(orders.length - 1, scope);
|
|
928
|
+
};
|
|
929
|
+
};
|
|
930
|
+
|
|
931
|
+
const compileRandomAction = (expression: Expression, environment: Environment) => {
|
|
932
|
+
if (expression.kind === "Exists") return compileRandomExists(expression, environment);
|
|
933
|
+
if (expression.kind !== "Or") return undefined;
|
|
934
|
+
const runners = expression.operands.map((operand) => getRunner(operand, environment, false));
|
|
935
|
+
return expression.isBulleted
|
|
936
|
+
? compileRandomChoice(runners)
|
|
937
|
+
: runners.reduce((left, right) => compileRandomChoice([left, right]));
|
|
938
|
+
};
|
|
939
|
+
|
|
816
940
|
const compileAction = (
|
|
817
941
|
expression: Expression,
|
|
818
942
|
environment: Environment,
|
|
@@ -852,12 +976,8 @@ const compileAction = (
|
|
|
852
976
|
const rest = compileConjunction(hoisted.rest, environment, isInit);
|
|
853
977
|
return (run, scope, partial, action, isFixed, onComplete) => {
|
|
854
978
|
const context = getContext(run, scope, partial);
|
|
855
|
-
const sets = expression.bounds
|
|
856
|
-
getContextElements(
|
|
857
|
-
evaluate(innerBound.set, context),
|
|
858
|
-
innerBound.set,
|
|
859
|
-
environment.runtime.version,
|
|
860
|
-
),
|
|
979
|
+
const sets = mapBoundSets(expression.bounds, (set) =>
|
|
980
|
+
getContextElements(evaluate(set, context), set, environment.runtime.version),
|
|
861
981
|
);
|
|
862
982
|
if (sets.some((elements) => elements.length === 0)) return;
|
|
863
983
|
const visit = (index: number, boundScope: Scope | undefined): void => {
|
|
@@ -955,7 +1075,6 @@ const compileAction = (
|
|
|
955
1075
|
const arm = arms.find((candidate) => {
|
|
956
1076
|
const value = evaluate(candidate.condition, context);
|
|
957
1077
|
if (typeof value === "boolean") return value;
|
|
958
|
-
// TLC leaves out the space before the kind under ENABLED.
|
|
959
1078
|
throw createRunError(
|
|
960
1079
|
run,
|
|
961
1080
|
`In computing ${getComputation(run)}, a non-boolean expression${run.isEnabled ? "" : " "}(${getKindString(value)}) was used as a guard condition of a CASE.\n${describeNode(candidate.source)}`,
|
|
@@ -995,7 +1114,11 @@ const compileAction = (
|
|
|
995
1114
|
return compileUnchanged(expression.expression, environment);
|
|
996
1115
|
case "AngleAction": {
|
|
997
1116
|
const body = getChildRunner(expression.action);
|
|
998
|
-
const unchanged =
|
|
1117
|
+
const unchanged: Expression = {
|
|
1118
|
+
kind: "Unchanged",
|
|
1119
|
+
expression: expression.subscript,
|
|
1120
|
+
location: expression.subscript.location,
|
|
1121
|
+
};
|
|
999
1122
|
const isUnchanged = (run: Run, scope: Scope | undefined, nextPartial: State) => {
|
|
1000
1123
|
try {
|
|
1001
1124
|
return holds(run, unchanged, getContext(run, scope, nextPartial));
|
|
@@ -1011,11 +1134,11 @@ const compileAction = (
|
|
|
1011
1134
|
});
|
|
1012
1135
|
}
|
|
1013
1136
|
case "BoxAction":
|
|
1014
|
-
return
|
|
1015
|
-
|
|
1016
|
-
|
|
1017
|
-
|
|
1018
|
-
|
|
1137
|
+
return compileDisjunction(
|
|
1138
|
+
[expression.action, getUnchangedWrapper(expression.subscript)],
|
|
1139
|
+
environment,
|
|
1140
|
+
isInit,
|
|
1141
|
+
);
|
|
1019
1142
|
case "Label":
|
|
1020
1143
|
return getChildRunner(expression.body);
|
|
1021
1144
|
case "Identifier":
|
|
@@ -1038,11 +1161,19 @@ const compileAction = (
|
|
|
1038
1161
|
const right = getChildRunner(args[1]);
|
|
1039
1162
|
return (run, scope, partial, action, isFixed, onComplete) => {
|
|
1040
1163
|
const condition = evaluate(args[0], getContext(run, scope, partial));
|
|
1041
|
-
|
|
1042
|
-
|
|
1043
|
-
|
|
1044
|
-
|
|
1045
|
-
|
|
1164
|
+
if (typeof condition !== "boolean") {
|
|
1165
|
+
const kind = getKindString(condition);
|
|
1166
|
+
const range = describeRange(expression);
|
|
1167
|
+
throw createRunError(
|
|
1168
|
+
run,
|
|
1169
|
+
run.isInit
|
|
1170
|
+
? `In computing initial states of a predicate of form P => Q, P was ${kind}\n.${range}`
|
|
1171
|
+
: run.isEnabled
|
|
1172
|
+
? `While computing ENABLED of an expression of the form P => Q, P was ${kind}.\n${range}`
|
|
1173
|
+
: `In computing next states of a predicate of the form P => Q, P was\n${kind}.\n${range}`,
|
|
1174
|
+
);
|
|
1175
|
+
}
|
|
1176
|
+
if (!condition) {
|
|
1046
1177
|
onComplete(partial, action);
|
|
1047
1178
|
return;
|
|
1048
1179
|
}
|
|
@@ -1056,7 +1187,6 @@ const compileAction = (
|
|
|
1056
1187
|
}
|
|
1057
1188
|
};
|
|
1058
1189
|
|
|
1059
|
-
// A partial state that assigns no variable, which a run fills in as it assigns them.
|
|
1060
1190
|
const getEmptyState = (environment: Environment): State =>
|
|
1061
1191
|
environment.variables.map((): Value | undefined => undefined);
|
|
1062
1192
|
|
|
@@ -1075,7 +1205,6 @@ export const isEnabled = (expression: Expression, context: Context): boolean =>
|
|
|
1075
1205
|
);
|
|
1076
1206
|
}
|
|
1077
1207
|
const environment = context.environment;
|
|
1078
|
-
// TLC computes ENABLED again with its call stack recorded as it computes successors.
|
|
1079
1208
|
if (environment.callStack) return replayEnabled(expression, context.scope, state, environment);
|
|
1080
1209
|
const run: Run = {
|
|
1081
1210
|
environment,
|
|
@@ -1083,8 +1212,9 @@ export const isEnabled = (expression: Expression, context: Context): boolean =>
|
|
|
1083
1212
|
isEnabled: true,
|
|
1084
1213
|
current: state,
|
|
1085
1214
|
isStopped: false,
|
|
1215
|
+
generator: undefined,
|
|
1216
|
+
successors: 0,
|
|
1086
1217
|
};
|
|
1087
|
-
// TLC stops computing ENABLED at the first successor, so it skips the rest of the action.
|
|
1088
1218
|
getRunner(expression, environment, false)(
|
|
1089
1219
|
run,
|
|
1090
1220
|
context.scope,
|
|
@@ -1103,6 +1233,7 @@ export const forEachInitialState = (
|
|
|
1103
1233
|
environment: Environment,
|
|
1104
1234
|
onState: (state: Value[]) => boolean,
|
|
1105
1235
|
scope?: Scope,
|
|
1236
|
+
onIncomplete?: (state: State) => boolean,
|
|
1106
1237
|
) => {
|
|
1107
1238
|
const run: Run = {
|
|
1108
1239
|
environment,
|
|
@@ -1110,6 +1241,8 @@ export const forEachInitialState = (
|
|
|
1110
1241
|
isEnabled: false,
|
|
1111
1242
|
current: undefined,
|
|
1112
1243
|
isStopped: false,
|
|
1244
|
+
generator: undefined,
|
|
1245
|
+
successors: 0,
|
|
1113
1246
|
};
|
|
1114
1247
|
getRunner(expression, environment, true)(
|
|
1115
1248
|
run,
|
|
@@ -1120,8 +1253,10 @@ export const forEachInitialState = (
|
|
|
1120
1253
|
(partial) => {
|
|
1121
1254
|
if (run.isStopped) return;
|
|
1122
1255
|
if (!isComplete(partial)) {
|
|
1123
|
-
|
|
1124
|
-
|
|
1256
|
+
if (onIncomplete) {
|
|
1257
|
+
run.isStopped = onIncomplete([...partial]);
|
|
1258
|
+
return;
|
|
1259
|
+
}
|
|
1125
1260
|
throw setExitCode(new TlaIllegalStateError([...partial]), EXIT_STATUS.error);
|
|
1126
1261
|
}
|
|
1127
1262
|
run.isStopped = onState(partial);
|
|
@@ -1153,6 +1288,8 @@ export const forEachSuccessor = (
|
|
|
1153
1288
|
environment: Environment,
|
|
1154
1289
|
onSuccessor: (successor: Successor) => boolean,
|
|
1155
1290
|
scope?: Scope,
|
|
1291
|
+
generator?: JavaRandom,
|
|
1292
|
+
onUnsatisfied?: Run["onUnsatisfied"],
|
|
1156
1293
|
) => {
|
|
1157
1294
|
const run: Run = {
|
|
1158
1295
|
environment,
|
|
@@ -1160,8 +1297,10 @@ export const forEachSuccessor = (
|
|
|
1160
1297
|
isEnabled: false,
|
|
1161
1298
|
current: state,
|
|
1162
1299
|
isStopped: false,
|
|
1300
|
+
generator,
|
|
1301
|
+
successors: 0,
|
|
1302
|
+
onUnsatisfied,
|
|
1163
1303
|
};
|
|
1164
|
-
const counter = { successors: 0 };
|
|
1165
1304
|
getRunner(expression, environment, false)(
|
|
1166
1305
|
run,
|
|
1167
1306
|
scope,
|
|
@@ -1171,7 +1310,9 @@ export const forEachSuccessor = (
|
|
|
1171
1310
|
(partial, action) => {
|
|
1172
1311
|
if (run.isStopped) return;
|
|
1173
1312
|
if (!isComplete(partial)) {
|
|
1174
|
-
const missing = environment.variables.filter(
|
|
1313
|
+
const missing = environment.variables.filter(
|
|
1314
|
+
(_name, index) => partial[index] === undefined,
|
|
1315
|
+
);
|
|
1175
1316
|
throw new TlaIncompleteSuccessorError(
|
|
1176
1317
|
`Successor state is not completely specified by action ${action ?? "Next"}. The following variables are not assigned: ${missing.join(", ")}`,
|
|
1177
1318
|
partial,
|
|
@@ -1179,11 +1320,39 @@ export const forEachSuccessor = (
|
|
|
1179
1320
|
missing,
|
|
1180
1321
|
);
|
|
1181
1322
|
}
|
|
1182
|
-
|
|
1323
|
+
run.successors++;
|
|
1183
1324
|
run.isStopped = onSuccessor({ state: partial, action });
|
|
1184
1325
|
},
|
|
1185
1326
|
);
|
|
1186
|
-
return
|
|
1327
|
+
return run.successors;
|
|
1328
|
+
};
|
|
1329
|
+
|
|
1330
|
+
export const hasIncompleteSuccessor = (
|
|
1331
|
+
expression: Expression,
|
|
1332
|
+
state: Value[],
|
|
1333
|
+
environment: Environment,
|
|
1334
|
+
scope?: Scope,
|
|
1335
|
+
) => {
|
|
1336
|
+
const run: Run = {
|
|
1337
|
+
environment,
|
|
1338
|
+
isInit: false,
|
|
1339
|
+
isEnabled: false,
|
|
1340
|
+
current: state,
|
|
1341
|
+
isStopped: false,
|
|
1342
|
+
generator: undefined,
|
|
1343
|
+
successors: 0,
|
|
1344
|
+
};
|
|
1345
|
+
getRunner(expression, environment, false)(
|
|
1346
|
+
run,
|
|
1347
|
+
scope,
|
|
1348
|
+
getEmptyState(environment),
|
|
1349
|
+
undefined,
|
|
1350
|
+
false,
|
|
1351
|
+
(partial) => {
|
|
1352
|
+
if (!isComplete(partial)) run.isStopped = true;
|
|
1353
|
+
},
|
|
1354
|
+
);
|
|
1355
|
+
return run.isStopped;
|
|
1187
1356
|
};
|
|
1188
1357
|
|
|
1189
1358
|
export const getSuccessors = (
|