tla-ts 0.0.9 → 0.0.10-dev.06b481ee0
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 +30 -1
- package/dist/compile.cjs +23 -0
- package/dist/compile.js +23 -0
- package/dist/deciders.cjs +41 -37
- package/dist/deciders.js +48 -44
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +122 -12
- package/dist/index.d.ts +122 -12
- 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 +2746 -410
- package/dist/prove.js +2745 -409
- package/dist/run.cjs +144 -31
- package/dist/run.js +144 -31
- package/dist/tlapm.cjs +2 -2
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +134 -104
- package/dist/transfer.js +134 -104
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +3 -1
- package/src/ast.ts +56 -60
- package/src/bags.ts +128 -110
- package/src/builtins.ts +31 -77
- package/src/bundled-modules.ts +1 -8
- package/src/check-failure.ts +118 -0
- package/src/check-trace.ts +320 -0
- package/src/check.ts +1156 -888
- package/src/cli/options.ts +12 -32
- package/src/cli/run.ts +0 -2
- package/src/cli/runtime-invariants.ts +100 -0
- package/src/cli/shared.ts +19 -12
- package/src/cli/tlapm.ts +433 -82
- package/src/cli/tlc-arguments.ts +652 -0
- package/src/cli/tlc-output.ts +701 -0
- package/src/cli/tlc-usage.ts +360 -0
- package/src/cli/tlc.ts +330 -659
- package/src/cli/typescript.ts +23 -0
- package/src/cli/xml-exporter.ts +27 -49
- package/src/cli.ts +0 -1
- package/src/codegen.ts +217 -82
- package/src/config.ts +140 -109
- package/src/coverage.ts +1019 -0
- package/src/dependencies.ts +101 -66
- package/src/dfid.ts +683 -0
- package/src/environment-config.ts +315 -0
- package/src/environment.ts +263 -370
- package/src/errors.ts +107 -57
- package/src/evaluate.ts +898 -369
- package/src/exit-codes.ts +63 -13
- package/src/fingerprints.ts +75 -11
- package/src/index.ts +3 -0
- package/src/instances.ts +137 -22
- package/src/java-hash.ts +21 -0
- package/src/java-overrides.ts +6 -21
- package/src/json-reader.ts +455 -0
- package/src/json.ts +252 -139
- package/src/levels.ts +231 -154
- package/src/lexer.ts +83 -101
- package/src/liveness-checker.ts +743 -322
- package/src/liveness.ts +230 -133
- package/src/obligations/action.ts +17 -44
- package/src/obligations/anonymize.ts +120 -95
- package/src/obligations/enabled-axioms.ts +218 -0
- package/src/obligations/equality.ts +1 -3
- package/src/obligations/expression.ts +37 -26
- package/src/obligations/format.ts +0 -10
- package/src/obligations/generate.ts +66 -64
- package/src/obligations/index.ts +39 -20
- package/src/obligations/levels.ts +27 -18
- package/src/obligations/module.ts +28 -55
- package/src/obligations/normalize.ts +31 -41
- package/src/obligations/operators.ts +0 -3
- package/src/obligations/pragma.ts +52 -24
- package/src/obligations/printer.ts +94 -63
- package/src/obligations/proof.ts +3 -6
- package/src/obligations/regroup.ts +0 -5
- package/src/obligations/simplify.ts +57 -63
- package/src/obligations/source.ts +121 -95
- package/src/obligations/subexpression.ts +49 -28
- package/src/obligations/substitution.ts +1 -5
- package/src/obligations/temporal.ts +12 -20
- package/src/obligations/tuples.ts +2 -10
- package/src/parallel-worker.ts +36 -60
- package/src/parallel.ts +64 -73
- package/src/parser.ts +1184 -531
- 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 +8 -13
- package/src/prover/deciders.ts +12 -13
- package/src/prover/first-order.ts +0 -11
- package/src/prover/isabelle/decide.ts +3 -31
- package/src/prover/isabelle/encode.ts +82 -64
- package/src/prover/isabelle/isar/attrib.ts +250 -0
- package/src/prover/isabelle/isar/context.ts +335 -0
- package/src/prover/isabelle/isar/induct.ts +382 -0
- package/src/prover/isabelle/isar/inner-syntax.ts +262 -117
- package/src/prover/isabelle/isar/method.ts +510 -226
- package/src/prover/isabelle/isar/proof.ts +570 -23
- package/src/prover/isabelle/isar/rule-cases.ts +226 -0
- package/src/prover/isabelle/isar/theory.ts +488 -88
- package/src/prover/isabelle/isar/toplevel.ts +331 -0
- package/src/prover/isabelle/isar/type-check.ts +99 -38
- package/src/prover/isabelle/provers/blast/blast.ts +16 -105
- package/src/prover/isabelle/provers/blast/branch.ts +0 -33
- package/src/prover/isabelle/provers/blast/prove.ts +0 -36
- package/src/prover/isabelle/provers/blast/rules.ts +5 -45
- package/src/prover/isabelle/provers/blast/state.ts +1 -29
- package/src/prover/isabelle/provers/blast/term.ts +8 -37
- package/src/prover/isabelle/provers/clasimp.ts +1 -15
- package/src/prover/isabelle/provers/classical.ts +58 -61
- package/src/prover/isabelle/provers/hypsubst.ts +29 -54
- package/src/prover/isabelle/pure/bicompose.ts +24 -39
- package/src/prover/isabelle/pure/consts.ts +0 -8
- package/src/prover/isabelle/pure/conv.ts +2 -18
- package/src/prover/isabelle/pure/drule.ts +95 -45
- package/src/prover/isabelle/pure/envir.ts +2 -53
- package/src/prover/isabelle/pure/goal.ts +1 -9
- 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 -16
- package/src/prover/isabelle/pure/name.ts +1 -10
- package/src/prover/isabelle/pure/net.ts +2 -60
- package/src/prover/isabelle/pure/object-logic.ts +15 -16
- package/src/prover/isabelle/pure/pattern.ts +1 -20
- package/src/prover/isabelle/pure/raw-simplifier.ts +16 -63
- package/src/prover/isabelle/pure/rewriter.ts +34 -77
- package/src/prover/isabelle/pure/search.ts +2 -11
- package/src/prover/isabelle/pure/seq.ts +0 -11
- package/src/prover/isabelle/pure/simplifier.ts +27 -16
- package/src/prover/isabelle/pure/table.ts +2 -33
- package/src/prover/isabelle/pure/tactic.ts +11 -23
- package/src/prover/isabelle/pure/tactical.ts +47 -48
- package/src/prover/isabelle/pure/term-ord.ts +1 -7
- package/src/prover/isabelle/pure/term.ts +4 -47
- package/src/prover/isabelle/pure/thm.ts +26 -48
- package/src/prover/isabelle/pure/type.ts +1 -16
- package/src/prover/isabelle/pure/unify.ts +19 -31
- package/src/prover/isabelle/pure/variable.ts +2 -8
- package/src/prover/isabelle/tla/classical-setup.ts +17 -25
- package/src/prover/isabelle/tla/context.ts +65 -26
- package/src/prover/isabelle/tla/logic-data.ts +1 -1
- package/src/prover/isabelle/tla/logic.ts +53 -32
- package/src/prover/isabelle/tla/simpdata.ts +45 -44
- package/src/prover/isabelle/tools/intuitionistic.ts +28 -21
- package/src/prover/ocaml.ts +4 -7
- package/src/prover/prep/action.ts +33 -66
- package/src/prover/prep/enabled-axioms.ts +22 -20
- package/src/prover/prep/fingerprint.ts +2 -21
- package/src/prover/prep/level-comparison.ts +8 -12
- package/src/prover/prep/md5.ts +26 -31
- package/src/prover/prep/methods.ts +189 -86
- package/src/prover/prep/normalize.ts +42 -37
- package/src/prover/prove-worker.ts +0 -2
- package/src/prover/prove.ts +398 -133
- package/src/prover/ptl/decide.ts +96 -56
- package/src/prover/ptl/encode.ts +15 -38
- package/src/prover/ptl/sat.ts +24 -32
- package/src/prover/ptl/tableau.ts +40 -28
- package/src/prover/smt/arithmetic.ts +310 -0
- package/src/prover/smt/axioms.ts +12 -15
- package/src/prover/smt/context.ts +60 -32
- package/src/prover/smt/data.ts +517 -401
- package/src/prover/smt/encode.ts +155 -85
- package/src/prover/smt/extensionality.ts +5 -13
- package/src/prover/smt/flatten.ts +7 -28
- package/src/prover/smt/format.ts +33 -14
- package/src/prover/smt/instances.ts +7 -11
- package/src/prover/smt/layout.ts +91 -0
- package/src/prover/smt/rewrite.ts +1021 -658
- package/src/prover/smt/simplify.ts +441 -0
- package/src/prover/smt/solver/ackermannize-bv-tactic.ts +61 -0
- package/src/prover/smt/solver/ackr-helper.ts +179 -0
- package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
- package/src/prover/smt/solver/act-cache.ts +0 -16
- package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
- package/src/prover/smt/solver/aig-tactic.ts +52 -0
- package/src/prover/smt/solver/aig.ts +889 -0
- package/src/prover/smt/solver/arith-rewriter.ts +626 -56
- package/src/prover/smt/solver/arith-terms.ts +121 -0
- package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
- package/src/prover/smt/solver/array-rewriter.ts +319 -0
- package/src/prover/smt/solver/array.ts +1 -3
- package/src/prover/smt/solver/asserted-formulas.ts +241 -99
- package/src/prover/smt/solver/ast-lt.ts +165 -21
- package/src/prover/smt/solver/ast-util.ts +160 -7
- package/src/prover/smt/solver/ast.ts +1480 -184
- package/src/prover/smt/solver/auf-solver.ts +30 -56
- package/src/prover/smt/solver/bit-blast-tactic.ts +608 -0
- package/src/prover/smt/solver/bit-blaster.ts +871 -0
- package/src/prover/smt/solver/blast-term-ite.ts +47 -0
- package/src/prover/smt/solver/bound-manager.ts +196 -0
- package/src/prover/smt/solver/bound-simplifier.ts +598 -0
- package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
- package/src/prover/smt/solver/bv-decl-plugin.ts +341 -0
- package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
- package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
- package/src/prover/smt/solver/bv1-blast.ts +214 -0
- package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
- package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
- package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
- package/src/prover/smt/solver/card2bv.ts +127 -0
- package/src/prover/smt/solver/case-split-queue.ts +0 -10
- package/src/prover/smt/solver/cg-table.ts +39 -42
- package/src/prover/smt/solver/check-logic.ts +330 -0
- package/src/prover/smt/solver/clause.ts +0 -27
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +293 -0
- package/src/prover/smt/solver/conflict-resolution.ts +78 -11
- package/src/prover/smt/solver/context.ts +600 -187
- package/src/prover/smt/solver/ctx-simplify.ts +34 -52
- package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
- package/src/prover/smt/solver/datatype-decl-plugin.ts +580 -0
- package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
- package/src/prover/smt/solver/demodulator.ts +786 -0
- package/src/prover/smt/solver/dependent-expr-state.ts +93 -0
- package/src/prover/smt/solver/der.ts +39 -30
- package/src/prover/smt/solver/diff-neq.ts +205 -0
- package/src/prover/smt/solver/distribute-forall.ts +57 -0
- package/src/prover/smt/solver/dom-simplify.ts +511 -0
- package/src/prover/smt/solver/dt2bv-tactic.ts +296 -0
- package/src/prover/smt/solver/dyn-ack.ts +0 -11
- package/src/prover/smt/solver/e-matching.ts +9 -41
- package/src/prover/smt/solver/elim-bounds.ts +89 -0
- package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
- package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +542 -0
- package/src/prover/smt/solver/enode.ts +100 -23
- package/src/prover/smt/solver/eq2bv-tactic.ts +218 -0
- package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
- package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
- package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
- package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
- package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
- package/src/prover/smt/solver/euf/array-solver.ts +306 -0
- package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
- package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
- package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
- package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
- package/src/prover/smt/solver/euf/egraph.ts +901 -0
- package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
- package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
- package/src/prover/smt/solver/euf/mam.ts +1046 -0
- package/src/prover/smt/solver/euf/q-ematch.ts +829 -0
- package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
- package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
- package/src/prover/smt/solver/euf/q-solver.ts +361 -0
- package/src/prover/smt/solver/euf/th-solver.ts +328 -0
- package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
- package/src/prover/smt/solver/expr-ref.ts +0 -5
- package/src/prover/smt/solver/expr-safe-replace.ts +26 -7
- package/src/prover/smt/solver/expr2polynomial.ts +271 -0
- package/src/prover/smt/solver/factor.ts +163 -0
- package/src/prover/smt/solver/fd-solver.ts +734 -0
- package/src/prover/smt/solver/fingerprints.ts +15 -26
- package/src/prover/smt/solver/fix-dl-var.ts +147 -0
- package/src/prover/smt/solver/flat-literals.ts +0 -9
- package/src/prover/smt/solver/fm-tactic.ts +884 -0
- package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
- package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
- package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
- package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
- package/src/prover/smt/solver/goal.ts +179 -28
- package/src/prover/smt/solver/goal2nlsat.ts +216 -0
- package/src/prover/smt/solver/guard-set.ts +219 -0
- package/src/prover/smt/solver/hash.ts +0 -9
- package/src/prover/smt/solver/hashtable.ts +30 -23
- package/src/prover/smt/solver/inf-eps.ts +63 -0
- package/src/prover/smt/solver/inj-axiom.ts +101 -0
- package/src/prover/smt/solver/internalizer.ts +113 -133
- package/src/prover/smt/solver/lackr.ts +381 -0
- package/src/prover/smt/solver/lbool.ts +0 -2
- package/src/prover/smt/solver/lia2card.ts +268 -0
- package/src/prover/smt/solver/lia2pb.ts +154 -0
- package/src/prover/smt/solver/literal.ts +0 -4
- package/src/prover/smt/solver/logic-tactics.ts +355 -0
- package/src/prover/smt/solver/lp/bound-propagator.ts +7 -26
- package/src/prover/smt/solver/lp/constraints.ts +1 -8
- package/src/prover/smt/solver/lp/containers.ts +18 -31
- package/src/prover/smt/solver/lp/core-solver.ts +35 -37
- package/src/prover/smt/solver/lp/cross-nested.ts +4 -21
- package/src/prover/smt/solver/lp/dep-intervals.ts +6 -24
- package/src/prover/smt/solver/lp/dependency.ts +0 -5
- package/src/prover/smt/solver/lp/dioph-eq.ts +8 -103
- package/src/prover/smt/solver/lp/explanation.ts +0 -6
- package/src/prover/smt/solver/lp/gomory.ts +8 -22
- package/src/prover/smt/solver/lp/hnf-cutter.ts +16 -23
- package/src/prover/smt/solver/lp/hnf.ts +10 -28
- package/src/prover/smt/solver/lp/int-cube.ts +17 -39
- package/src/prover/smt/solver/lp/int-solver.ts +3 -35
- package/src/prover/smt/solver/lp/lar-solver.ts +70 -83
- package/src/prover/smt/solver/lp/lar-term.ts +0 -5
- package/src/prover/smt/solver/lp/lp-settings.ts +6 -16
- package/src/prover/smt/solver/lp/maximize-term.ts +76 -52
- package/src/prover/smt/solver/lp/nex-creator.ts +7 -30
- package/src/prover/smt/solver/lp/nex.ts +2 -7
- package/src/prover/smt/solver/lp/nla-backoff.ts +0 -5
- package/src/prover/smt/solver/lp/nla-basics.ts +48 -30
- package/src/prover/smt/solver/lp/nla-core.ts +92 -136
- package/src/prover/smt/solver/lp/nla-divisions.ts +31 -43
- package/src/prover/smt/solver/lp/nla-emonics.ts +3 -21
- package/src/prover/smt/solver/lp/nla-factorization.ts +0 -4
- package/src/prover/smt/solver/lp/nla-grobner.ts +177 -149
- package/src/prover/smt/solver/lp/nla-horner.ts +2 -12
- package/src/prover/smt/solver/lp/nla-intervals.ts +1 -12
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +15 -42
- package/src/prover/smt/solver/lp/nla-monotone.ts +1 -6
- package/src/prover/smt/solver/lp/nla-order.ts +0 -13
- package/src/prover/smt/solver/lp/nla-patcher.ts +3 -7
- package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
- package/src/prover/smt/solver/lp/nla-tangents.ts +0 -10
- package/src/prover/smt/solver/lp/nla-throttle.ts +0 -6
- package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
- package/src/prover/smt/solver/lp/nla-types.ts +0 -12
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -26
- package/src/prover/smt/solver/lp/nra-solver.ts +164 -147
- package/src/prover/smt/solver/lp/numeric-pair.ts +0 -4
- package/src/prover/smt/solver/lp/pdd-interval.ts +6 -5
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +61 -34
- package/src/prover/smt/solver/lp/pdd-solver.ts +74 -72
- package/src/prover/smt/solver/lp/pdd.ts +730 -358
- package/src/prover/smt/solver/lp/random-updater.ts +0 -9
- package/src/prover/smt/solver/lp/static-matrix.ts +8 -19
- package/src/prover/smt/solver/lp/union-find.ts +5 -5
- package/src/prover/smt/solver/macro-finder.ts +530 -0
- package/src/prover/smt/solver/mam-compiler.ts +129 -139
- package/src/prover/smt/solver/mam-interpreter.ts +0 -21
- package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
- package/src/prover/smt/solver/max-cliques.ts +105 -0
- package/src/prover/smt/solver/maxcore.ts +310 -0
- package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -21
- package/src/prover/smt/solver/maxlex.ts +115 -0
- package/src/prover/smt/solver/maxsmt-base.ts +106 -0
- package/src/prover/smt/solver/maxsmt.ts +92 -0
- package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
- package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
- package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
- package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
- package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
- package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
- package/src/prover/smt/solver/model-based-opt.ts +844 -0
- package/src/prover/smt/solver/model-checker.ts +20 -63
- package/src/prover/smt/solver/model-evaluator.ts +192 -40
- package/src/prover/smt/solver/model-finder.ts +14 -32
- package/src/prover/smt/solver/model-generator.ts +104 -46
- package/src/prover/smt/solver/model-macro-solver.ts +60 -114
- package/src/prover/smt/solver/model-printer.ts +214 -0
- package/src/prover/smt/solver/mpf.ts +709 -0
- package/src/prover/smt/solver/mus.ts +50 -0
- package/src/prover/smt/solver/muz/dl-context.ts +382 -0
- package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
- package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
- package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
- package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
- package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
- package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
- package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
- package/src/prover/smt/solver/muz/dl-rule.ts +495 -0
- package/src/prover/smt/solver/muz/hnf.ts +201 -0
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
- package/src/prover/smt/solver/muz/horn-tactic.ts +214 -0
- package/src/prover/smt/solver/muz/rule-properties.ts +359 -0
- package/src/prover/smt/solver/muz/spacer-context.ts +1404 -0
- package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
- package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
- package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
- package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
- package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
- package/src/prover/smt/solver/muz/substitution.ts +203 -0
- package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
- package/src/prover/smt/solver/nlqsat.ts +484 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +357 -236
- package/src/prover/smt/solver/nlsat/atoms.ts +73 -54
- package/src/prover/smt/solver/nlsat/evaluator.ts +16 -22
- package/src/prover/smt/solver/nlsat/explain.ts +429 -275
- package/src/prover/smt/solver/nlsat/interval-set.ts +9 -51
- package/src/prover/smt/solver/nlsat/levelwise.ts +477 -344
- package/src/prover/smt/solver/nlsat/mpbq.ts +47 -14
- package/src/prover/smt/solver/nlsat/polynomial.ts +2385 -832
- package/src/prover/smt/solver/nlsat/solver.ts +297 -156
- package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
- package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
- package/src/prover/smt/solver/nlsat/types.ts +0 -9
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +9 -51
- package/src/prover/smt/solver/nlsat/upolynomial.ts +49 -109
- package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
- package/src/prover/smt/solver/nnf.ts +112 -61
- package/src/prover/smt/solver/normalize-bounds.ts +53 -0
- package/src/prover/smt/solver/occf.ts +97 -0
- package/src/prover/smt/solver/opt-context.ts +801 -0
- package/src/prover/smt/solver/opt-nlsat.ts +386 -0
- package/src/prover/smt/solver/opt-pareto.ts +301 -0
- package/src/prover/smt/solver/opt-preprocess.ts +101 -0
- package/src/prover/smt/solver/opt-solver.ts +312 -0
- package/src/prover/smt/solver/opt-value.ts +55 -0
- package/src/prover/smt/solver/optsmt.ts +692 -0
- package/src/prover/smt/solver/parallel-tactic.ts +299 -0
- package/src/prover/smt/solver/pattern-inference.ts +21 -26
- package/src/prover/smt/solver/pb-rewriter.ts +281 -0
- package/src/prover/smt/solver/pb2bv-tactic.ts +540 -0
- package/src/prover/smt/solver/poly-rewriter.ts +261 -79
- package/src/prover/smt/solver/probes.ts +577 -0
- package/src/prover/smt/solver/propagate-values.ts +37 -30
- package/src/prover/smt/solver/proto-model.ts +650 -66
- package/src/prover/smt/solver/pull-quant.ts +28 -23
- package/src/prover/smt/solver/purify-arith.ts +632 -0
- package/src/prover/smt/solver/push-app-ite.ts +37 -0
- package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -0
- package/src/prover/smt/solver/qe-lite-der.ts +2 -31
- package/src/prover/smt/solver/qe-lite-fm.ts +4 -28
- package/src/prover/smt/solver/qe-lite.ts +41 -51
- package/src/prover/smt/solver/qe-mbp.ts +270 -0
- package/src/prover/smt/solver/qe.ts +1499 -0
- package/src/prover/smt/solver/qel.ts +25 -0
- package/src/prover/smt/solver/qi-queue.ts +0 -16
- package/src/prover/smt/solver/qsat.ts +829 -0
- package/src/prover/smt/solver/quant-hoist.ts +196 -0
- package/src/prover/smt/solver/quant-tactics.ts +17 -74
- package/src/prover/smt/solver/quantifier-analyzer.ts +26 -47
- package/src/prover/smt/solver/quantifier-manager.ts +22 -32
- package/src/prover/smt/solver/quasi-macros.ts +243 -0
- package/src/prover/smt/solver/random-gen.ts +0 -2
- package/src/prover/smt/solver/rational.ts +45 -8
- package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -0
- package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
- package/src/prover/smt/solver/reduce-args.ts +225 -0
- package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
- package/src/prover/smt/solver/ref-vector.ts +0 -6
- package/src/prover/smt/solver/relevancy.ts +2 -16
- package/src/prover/smt/solver/rewriter-tpl.ts +59 -135
- package/src/prover/smt/solver/rewriter.ts +507 -144
- package/src/prover/smt/solver/rlimit.ts +46 -24
- package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
- package/src/prover/smt/solver/sat/big.ts +177 -0
- package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
- package/src/prover/smt/solver/sat/clause.ts +203 -0
- package/src/prover/smt/solver/sat/cleaner.ts +94 -0
- package/src/prover/smt/solver/sat/config.ts +122 -0
- package/src/prover/smt/solver/sat/consequences.ts +203 -0
- package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
- package/src/prover/smt/solver/sat/goal2sat.ts +579 -0
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +464 -0
- package/src/prover/smt/solver/sat/model-converter.ts +136 -0
- package/src/prover/smt/solver/sat/pb-constraint.ts +268 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +1596 -0
- package/src/prover/smt/solver/sat/probing.ts +170 -0
- package/src/prover/smt/solver/sat/sat-tactic.ts +53 -0
- package/src/prover/smt/solver/sat/sat2goal.ts +189 -0
- package/src/prover/smt/solver/sat/scc.ts +142 -0
- package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
- package/src/prover/smt/solver/sat/solver.ts +2107 -0
- package/src/prover/smt/solver/sat/var-queue.ts +117 -0
- package/src/prover/smt/solver/sat/watch-list.ts +140 -0
- package/src/prover/smt/solver/search-tree.ts +284 -0
- package/src/prover/smt/solver/seq-axioms.ts +995 -0
- package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
- package/src/prover/smt/solver/seq-derive.ts +1298 -0
- package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
- package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
- package/src/prover/smt/solver/seq-factory.ts +89 -0
- package/src/prover/smt/solver/seq-monadic.ts +730 -0
- package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
- package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -0
- package/src/prover/smt/solver/seq-re-util.ts +758 -0
- package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
- package/src/prover/smt/solver/seq-regex-live.ts +200 -0
- package/src/prover/smt/solver/seq-rewriter.ts +2404 -0
- package/src/prover/smt/solver/seq-skolem.ts +294 -0
- package/src/prover/smt/solver/seq-subset.ts +165 -0
- package/src/prover/smt/solver/seq-view-witness.ts +353 -0
- package/src/prover/smt/solver/smt-consequences.ts +297 -0
- package/src/prover/smt/solver/smt-kernel.ts +124 -0
- package/src/prover/smt/solver/smt-logics.ts +66 -0
- package/src/prover/smt/solver/smt-setup.ts +589 -0
- package/src/prover/smt/solver/smt2-printer.ts +765 -0
- package/src/prover/smt/solver/smtlib-parser.ts +3546 -406
- package/src/prover/smt/solver/smtlib-script.ts +2134 -0
- package/src/prover/smt/solver/solve-eqs.ts +928 -0
- package/src/prover/smt/solver/solver.ts +135 -40
- package/src/prover/smt/solver/sort.ts +1 -5
- package/src/prover/smt/solver/static-features.ts +314 -0
- package/src/prover/smt/solver/sticky-generations.ts +0 -6
- package/src/prover/smt/solver/tactic.ts +2141 -0
- package/src/prover/smt/solver/term-enumeration.ts +205 -0
- package/src/prover/smt/solver/theory-array.ts +1240 -0
- package/src/prover/smt/solver/theory-bv.ts +1210 -0
- package/src/prover/smt/solver/theory-char.ts +355 -0
- package/src/prover/smt/solver/theory-datatype.ts +598 -0
- package/src/prover/smt/solver/theory-finite-set.ts +30 -0
- package/src/prover/smt/solver/theory-fpa.ts +389 -0
- package/src/prover/smt/solver/theory-lra-axioms.ts +55 -25
- package/src/prover/smt/solver/theory-lra-bounds.ts +31 -11
- package/src/prover/smt/solver/theory-lra-final-check.ts +60 -91
- package/src/prover/smt/solver/theory-lra-internalize.ts +96 -53
- package/src/prover/smt/solver/theory-lra-model.ts +23 -53
- package/src/prover/smt/solver/theory-lra-propagate.ts +34 -42
- package/src/prover/smt/solver/theory-lra-state.ts +7 -28
- package/src/prover/smt/solver/theory-lra.ts +189 -9
- package/src/prover/smt/solver/theory-pb.ts +951 -0
- package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
- package/src/prover/smt/solver/theory-recfun.ts +307 -0
- package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
- package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
- package/src/prover/smt/solver/theory-seq-state.ts +852 -0
- package/src/prover/smt/solver/theory-seq.ts +961 -0
- package/src/prover/smt/solver/theory-without-terms.ts +24 -0
- package/src/prover/smt/solver/theory.ts +189 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +486 -0
- package/src/prover/smt/solver/var-subst.ts +37 -39
- package/src/prover/smt/table.ts +3 -10
- package/src/prover/smt/types.ts +146 -0
- package/src/prover/tlapm/cache.ts +74 -48
- package/src/prover/tlapm/ocaml-marshal.ts +19 -21
- package/src/prover/tlapm/tlapm.ts +21 -20
- package/src/prover/tlapm-library.ts +3208 -0
- package/src/prover/verdict.ts +9 -2
- package/src/prover/zenon/check/check.ts +1 -11
- 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 +1 -6
- package/src/prover/zenon/check/relations.ts +2 -14
- package/src/prover/zenon/check/rewrites.ts +2 -21
- package/src/prover/zenon/check/sets.ts +40 -61
- package/src/prover/zenon/check/terms.ts +1 -19
- package/src/prover/zenon/check/tla.ts +0 -6
- package/src/prover/zenon/decide.ts +10 -19
- package/src/prover/zenon/encode.ts +0 -9
- package/src/prover/zenon/eqrel.ts +2 -15
- package/src/prover/zenon/equality-rules.ts +24 -6
- package/src/prover/zenon/expr.ts +29 -28
- package/src/prover/zenon/index-table.ts +33 -61
- package/src/prover/zenon/isar-case.ts +9 -21
- package/src/prover/zenon/isar.ts +37 -67
- package/src/prover/zenon/limits.ts +0 -4
- package/src/prover/zenon/llproof.ts +2 -22
- package/src/prover/zenon/mltoll.ts +66 -106
- package/src/prover/zenon/node.ts +20 -15
- package/src/prover/zenon/ocaml.ts +1 -17
- package/src/prover/zenon/parse.ts +9 -13
- package/src/prover/zenon/phrase.ts +2 -14
- package/src/prover/zenon/proof.ts +0 -11
- package/src/prover/zenon/propositional-rules.ts +0 -7
- package/src/prover/zenon/rules.ts +3 -8
- package/src/prover/zenon/search.ts +11 -35
- package/src/prover/zenon/tla/functions.ts +59 -33
- package/src/prover/zenon/tla/llproof.ts +67 -78
- package/src/prover/zenon/tla/records.ts +57 -35
- package/src/prover/zenon/tla/rewrites.ts +12 -21
- package/src/prover/zenon/tla/sets.ts +88 -59
- package/src/prover/zenon/tla/terms.ts +0 -8
- package/src/prover/zenon/tla/tla.ts +66 -66
- package/src/randomization.ts +81 -35
- package/src/resolve.ts +1132 -430
- package/src/runtime.ts +33 -23
- package/src/sany/builtins.ts +11 -14
- package/src/sany/generation.ts +383 -0
- package/src/sany/generator-def-entries.ts +210 -0
- package/src/sany/generator-definitions.ts +688 -0
- package/src/sany/generator-expressions.ts +1108 -0
- package/src/sany/generator-proofs.ts +665 -0
- package/src/sany/generator.ts +192 -2764
- package/src/sany/levels.ts +5 -35
- package/src/sany/lexer.ts +61 -80
- package/src/sany/linter.ts +0 -10
- package/src/sany/modules.ts +5 -7
- package/src/sany/nodes.ts +6 -44
- package/src/sany/parse-error.ts +39 -117
- package/src/sany/report.ts +32 -69
- package/src/sany/selectors.ts +60 -82
- package/src/sany/source.ts +1 -17
- package/src/sany/xml.ts +37 -120
- package/src/search.ts +913 -227
- package/src/simulate.ts +765 -0
- package/src/spec-description.ts +198 -104
- package/src/standard-definitions.ts +4 -4
- package/src/standard-modules.ts +302 -99
- package/src/state-graph.ts +52 -33
- package/src/subexpressions.ts +578 -166
- package/src/substitution-levels.ts +7 -7
- package/src/successors.ts +299 -108
- package/src/symmetry.ts +37 -28
- package/src/tableau.ts +29 -26
- package/src/tlc/fingerprint.ts +267 -79
- package/src/tlc/jar-data.ts +122 -6
- package/src/tlc/messages.ts +127 -56
- package/src/tlc/order.ts +53 -72
- package/src/tlc/random.ts +38 -49
- package/src/tlc/replay.ts +579 -230
- package/src/tlc/summary.ts +64 -60
- package/src/tlc/tlc-operators.ts +83 -47
- package/src/tlc/tlcext-operators.ts +205 -127
- package/src/tlc/trace-spec.ts +235 -0
- package/src/tlc/value-stream.ts +139 -0
- package/src/tlc/version.ts +1 -4
- package/src/trace-liveness.ts +529 -0
- package/src/transfer.ts +22 -25
- package/src/typed-tier.ts +6556 -0
- package/src/typescript/actions.ts +479 -0
- package/src/typescript/collections.ts +614 -0
- package/src/typescript/compile.ts +63 -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 +154 -0
- package/src/typescript/functions.ts +284 -0
- package/src/typescript/model.ts +162 -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 +167 -0
- package/src/typescript/types.ts +171 -0
- package/src/values.ts +945 -526
- package/src/worker.ts +7 -8
- package/src/prover/isabelle/isar/statement.ts +0 -57
- package/src/prover/smt/solver/z3-license.txt +0 -10
- package/src/prover/tlaps-module.ts +0 -510
- package/src/prover/zenon/LICENSE +0 -32
package/src/evaluate.ts
CHANGED
|
@@ -1,5 +1,6 @@
|
|
|
1
1
|
import {
|
|
2
2
|
getChildren,
|
|
3
|
+
getReferencedName,
|
|
3
4
|
isLocallyResolved,
|
|
4
5
|
type Bound,
|
|
5
6
|
type BoundPattern,
|
|
@@ -10,21 +11,41 @@ import {
|
|
|
10
11
|
type NumberExpression,
|
|
11
12
|
type OperatorParam,
|
|
12
13
|
type RecordField,
|
|
13
|
-
type SourceRange,
|
|
14
14
|
} from "./ast";
|
|
15
15
|
import { getKindString } from "./builtins";
|
|
16
|
-
import {
|
|
16
|
+
import {
|
|
17
|
+
isStackOverflow,
|
|
18
|
+
TlaEvaluationError,
|
|
19
|
+
TlaSetBoundError,
|
|
20
|
+
TlaUnassignedError,
|
|
21
|
+
formatRange,
|
|
22
|
+
} from "./errors";
|
|
17
23
|
import { EXIT_STATUS, setExitCode } from "./exit-codes";
|
|
18
24
|
import { generateEvaluator } from "./codegen";
|
|
25
|
+
import {
|
|
26
|
+
chargeContexts,
|
|
27
|
+
chargeFunctionConstruction,
|
|
28
|
+
chargeSetOperation,
|
|
29
|
+
costCoverage,
|
|
30
|
+
countCoverage,
|
|
31
|
+
createChargedEnumerator,
|
|
32
|
+
createProductSetEnumerator,
|
|
33
|
+
getCoverageNode,
|
|
34
|
+
runAtCoverageNode,
|
|
35
|
+
tagSubset,
|
|
36
|
+
type Coverage,
|
|
37
|
+
} from "./coverage";
|
|
19
38
|
import { MESSAGE_CODE } from "./tlc/messages";
|
|
20
39
|
import type { CheckerRuntime } from "./runtime";
|
|
21
40
|
import {
|
|
22
|
-
|
|
41
|
+
isEvaluatedAtStartup,
|
|
42
|
+
isExpressionImpure,
|
|
23
43
|
isImpureDefinition,
|
|
24
44
|
isNonconstant,
|
|
45
|
+
isTlcEvalReached,
|
|
25
46
|
type DefinitionFacts,
|
|
26
47
|
} from "./dependencies";
|
|
27
|
-
import { contextualApplications } from "./instances";
|
|
48
|
+
import { contextualApplications, substitutionFrames } from "./instances";
|
|
28
49
|
import { prettyPrint } from "./pretty-print";
|
|
29
50
|
import { isEnabled } from "./successors";
|
|
30
51
|
import {
|
|
@@ -32,12 +53,15 @@ import {
|
|
|
32
53
|
describeMissingArgument,
|
|
33
54
|
compareValues,
|
|
34
55
|
createFunction,
|
|
56
|
+
addBoundedElement,
|
|
35
57
|
createNonIntegerKeyError,
|
|
58
|
+
forEachElement,
|
|
59
|
+
isBeyondSetBound,
|
|
36
60
|
createRecord,
|
|
37
61
|
createEnumeratedSet,
|
|
38
62
|
createSortedFunction,
|
|
39
63
|
createSortedRecord,
|
|
40
|
-
|
|
64
|
+
createNormalizedSet,
|
|
41
65
|
createWrittenRecord,
|
|
42
66
|
createTuple,
|
|
43
67
|
formatValue,
|
|
@@ -47,6 +71,7 @@ import {
|
|
|
47
71
|
getIntervalElements,
|
|
48
72
|
getLazySubsets,
|
|
49
73
|
getStreamedElements,
|
|
74
|
+
normalizeShallowly,
|
|
50
75
|
getFunctionClass,
|
|
51
76
|
getNormalizedSetElements,
|
|
52
77
|
getSequenceElements,
|
|
@@ -81,7 +106,6 @@ export interface OperatorValue {
|
|
|
81
106
|
arity: number;
|
|
82
107
|
call: (args: Value[]) => Value;
|
|
83
108
|
expression?: Expression;
|
|
84
|
-
literalBody?: Value;
|
|
85
109
|
}
|
|
86
110
|
|
|
87
111
|
export type BuiltinArgument = Value | OperatorValue;
|
|
@@ -94,8 +118,8 @@ export interface Builtin {
|
|
|
94
118
|
evaluateUnary: ((value: Value) => Value) | undefined;
|
|
95
119
|
evaluateBinary: ((left: Value, right: Value) => Value) | undefined;
|
|
96
120
|
isStateLevel?: boolean;
|
|
97
|
-
// Whether TLC takes an application for a constant one although its value depends on the state.
|
|
98
121
|
isLevelConstant?: boolean;
|
|
122
|
+
isActionLevel?: boolean;
|
|
99
123
|
isLazy?: boolean;
|
|
100
124
|
}
|
|
101
125
|
|
|
@@ -116,12 +140,14 @@ export interface Thunk {
|
|
|
116
140
|
state: State | undefined;
|
|
117
141
|
next: State | undefined;
|
|
118
142
|
cache: Value | undefined;
|
|
119
|
-
// Whether the expression may build a set that streams until TLC caches it, so that the thunk
|
|
120
|
-
// caches only a settled value.
|
|
121
143
|
isStreamed: boolean;
|
|
144
|
+
isReleased?: boolean;
|
|
122
145
|
}
|
|
123
146
|
|
|
124
|
-
type Binding =
|
|
147
|
+
type Binding =
|
|
148
|
+
| { kind: "Value"; value: Value; argument?: Expression }
|
|
149
|
+
| Thunk
|
|
150
|
+
| { kind: "Operator"; operator: Operator };
|
|
125
151
|
|
|
126
152
|
export interface Scope {
|
|
127
153
|
name: string;
|
|
@@ -135,55 +161,37 @@ export interface Environment {
|
|
|
135
161
|
builtins: Map<string, Builtin>;
|
|
136
162
|
constants: Map<string, Value>;
|
|
137
163
|
substitutions: Map<string, string>;
|
|
138
|
-
// The name SANY gives each definition that a named instance such as `M == INSTANCE Module`
|
|
139
|
-
// copies, such as M!Op, by the key of the copy.
|
|
140
164
|
instanceNames: Map<string, string>;
|
|
141
165
|
variables: string[];
|
|
142
166
|
variableIndex: Map<string, number>;
|
|
143
167
|
facts: DefinitionFacts;
|
|
144
|
-
// The value of each constant definition TLC computed when it started, by the definition's id in
|
|
145
|
-
// facts. TLC evaluates a definition it failed to compute where the spec uses it.
|
|
146
168
|
startupValues: (Value | undefined)[];
|
|
147
|
-
|
|
148
|
-
// wraps the body of each in its substitutions.
|
|
169
|
+
tlcEvalValues: WeakMap<Expression, Value>;
|
|
149
170
|
substitutedDefinitions: Set<Definition>;
|
|
150
|
-
|
|
151
|
-
// code can serve, and of each reference to a definition.
|
|
171
|
+
instanceParams: Set<OperatorParam>;
|
|
152
172
|
evaluators: WeakMap<Expression, Evaluator>;
|
|
153
173
|
entryEvaluators: WeakMap<Expression, Evaluator>;
|
|
154
174
|
definitionEvaluators: WeakMap<Definition, Evaluator>;
|
|
155
|
-
// The expressions being evaluated, outermost first, when the environment replays an error to
|
|
156
|
-
// find where it occurred, as TLC's CallStackTool does.
|
|
157
175
|
callStack?: CallStack;
|
|
176
|
+
coverage?: Coverage;
|
|
158
177
|
}
|
|
159
178
|
|
|
160
179
|
export interface CallStack {
|
|
161
180
|
expressions: Expression[];
|
|
162
|
-
// TLC stops popping the stack once an evaluation fails, so it keeps where the failure occurred.
|
|
163
181
|
isFrozen: boolean;
|
|
164
|
-
// The expression that built each value of the replay that TLC's CallStackTool gives a source.
|
|
165
182
|
sources: WeakMap<ObjectValue, Expression>;
|
|
166
|
-
// The value each expression of the replay last evaluated to.
|
|
167
183
|
values: WeakMap<Expression, Value>;
|
|
168
|
-
// The expression each failure last left, which tells a failure of an operand from one of the
|
|
169
|
-
// method that computes the operator.
|
|
170
184
|
failures: WeakMap<Error, Expression>;
|
|
171
|
-
// The failure of a value with a source, which TLC raises as a FingerprintException.
|
|
172
185
|
fingerprint?: FingerprintFailure;
|
|
173
186
|
}
|
|
174
187
|
|
|
175
188
|
export interface FingerprintFailure {
|
|
176
|
-
// The sources of the values whose methods failed, outermost first.
|
|
177
189
|
sources: Expression[];
|
|
178
|
-
// The message of the error the innermost one raised.
|
|
179
190
|
reason: string;
|
|
180
191
|
}
|
|
181
192
|
|
|
182
|
-
// The operators of Tool#evalAppl whose value TLC's CallStackTool gives a source.
|
|
183
193
|
const SOURCED_OPERATORS = new Set(["SUBSET", "UNION", "DOMAIN", "\\cup", "\\cap", "\\"]);
|
|
184
194
|
|
|
185
|
-
// CallStackTool copies the SetPredValue, FcnLambdaValue and OpLambdaValue that an evaluation
|
|
186
|
-
// returns without their source, and a function TLC builds from a FcnLambdaValue has none.
|
|
187
195
|
const SOURCED_KINDS = new Set<Expression["kind"]>([
|
|
188
196
|
"SetEnumeration",
|
|
189
197
|
"SetFilter",
|
|
@@ -199,8 +207,6 @@ const isSourced = (expression: Expression) =>
|
|
|
199
207
|
SOURCED_KINDS.has(expression.kind) ||
|
|
200
208
|
(expression.kind === "Apply" && SOURCED_OPERATORS.has(expression.operator));
|
|
201
209
|
|
|
202
|
-
// The argument whose method Tool#evalAppl calls to compute an operator, as with S.member(e) for
|
|
203
|
-
// e \in S, f.apply(e) for f[e] when f is a function, or S.diff(T) for S \ T when S is Reducible.
|
|
204
210
|
const getReceiver = (expression: Expression, values: CallStack["values"]) => {
|
|
205
211
|
if (expression.kind === "FunctionApplication" || expression.kind === "Except") {
|
|
206
212
|
return expression.function;
|
|
@@ -221,8 +227,6 @@ export interface Context {
|
|
|
221
227
|
scope: Scope | undefined;
|
|
222
228
|
state: State | undefined;
|
|
223
229
|
next: State | undefined;
|
|
224
|
-
// EvalControl.KeepLazy, which Tool#evalAppl sets to evaluate the function it applies and which
|
|
225
|
-
// the evaluation passes on, so that a function constructor within builds a FcnLambdaValue.
|
|
226
230
|
isKeepLazy?: boolean;
|
|
227
231
|
}
|
|
228
232
|
|
|
@@ -246,15 +250,23 @@ const EXCEPT_AT = "@";
|
|
|
246
250
|
export const describeLocation = (expression: Expression) =>
|
|
247
251
|
`line ${expression.location.line}, column ${expression.location.column}`;
|
|
248
252
|
|
|
249
|
-
export const formatRange = (range: SourceRange) =>
|
|
250
|
-
`line ${range.start.line}, col ${range.start.column} to line ${range.end.line}, col ${range.end.column} of module ${range.module}`;
|
|
251
|
-
|
|
252
253
|
export const describeRange = (expression: Expression) => {
|
|
253
254
|
const range = expression.location.range;
|
|
254
255
|
return range ? formatRange(range) : describeLocation(expression);
|
|
255
256
|
};
|
|
256
257
|
|
|
257
|
-
|
|
258
|
+
const TEMPORAL_FORMS = {
|
|
259
|
+
Always: "[]A",
|
|
260
|
+
Eventually: "<>A",
|
|
261
|
+
WeakFairness: "WF",
|
|
262
|
+
StrongFairness: "SF",
|
|
263
|
+
};
|
|
264
|
+
|
|
265
|
+
const createTemporalFormulaError = (form: string, expression: Expression) =>
|
|
266
|
+
new TlaEvaluationError(
|
|
267
|
+
`TLC encountered a temporal formula (${form}) when evaluating a predicate or action.\n${describeRange(expression)}`,
|
|
268
|
+
);
|
|
269
|
+
|
|
258
270
|
export const describeNode = (expression: Expression) =>
|
|
259
271
|
expression.kind === "Number"
|
|
260
272
|
? (expression.text ?? String(expression.value))
|
|
@@ -265,8 +277,6 @@ export const createConditionError = (expression: Expression, value: Value) =>
|
|
|
265
277
|
`A non-boolean expression (${getKindString(value)}) was used as the condition of an IF.\n${describeRange(expression)}`,
|
|
266
278
|
);
|
|
267
279
|
|
|
268
|
-
// TLC parses an infix chain of /\ or \/ as nested binary junctions and a bulleted list as one
|
|
269
|
-
// junction list, and it words the error differently for each.
|
|
270
280
|
export const createJunctionError = (
|
|
271
281
|
expression: Expression & { kind: "And" | "Or" },
|
|
272
282
|
index: number,
|
|
@@ -287,12 +297,10 @@ export const createJunctionError = (
|
|
|
287
297
|
);
|
|
288
298
|
};
|
|
289
299
|
|
|
290
|
-
// TLC selects a field of a record, and of another function from the function it converts it to,
|
|
291
|
-
// which for a tuple keeps its domain as an interval.
|
|
292
300
|
export const getFieldSelector = (expression: Expression & { kind: "FieldAccess" }) => {
|
|
293
301
|
const field = expression.field;
|
|
294
302
|
const describeMissing = (record: Value) =>
|
|
295
|
-
`Attempted to select nonexistent field "${field}" from the record\n${formatValue(record)}\n${describeRange(expression)}`;
|
|
303
|
+
`Attempted to select nonexistent field "${field}" from the record\n${prettyPrint(formatValue(record))}\n${describeRange(expression)}`;
|
|
296
304
|
const describeNotInDomain = (functionValue: Value) =>
|
|
297
305
|
`Attempted to apply function:\n${prettyPrint(formatValue(functionValue))}\nto argument "${field}", which is not in the domain of the function.`;
|
|
298
306
|
return (value: Value) => {
|
|
@@ -303,17 +311,14 @@ export const getFieldSelector = (expression: Expression & { kind: "FieldAccess"
|
|
|
303
311
|
}
|
|
304
312
|
const functionClass = getFunctionClass(value);
|
|
305
313
|
if (functionClass === "tuple") throw createNonIntegerKeyError(field);
|
|
306
|
-
// Only TLC's RecordValue names the field it lacks. Any other function, such as a FcnRcdValue
|
|
307
|
-
// whose keys are strings, reports an argument outside its domain.
|
|
308
314
|
return applyFunction(
|
|
309
|
-
value,
|
|
315
|
+
value.kind === "LazyFunction" ? toFiniteFunction(value) : value,
|
|
310
316
|
field,
|
|
311
317
|
functionClass === "record" ? describeMissing : describeNotInDomain,
|
|
312
318
|
);
|
|
313
319
|
};
|
|
314
320
|
};
|
|
315
321
|
|
|
316
|
-
// TLC 1.7.4 words what a tuple or a record lacks differently.
|
|
317
322
|
export const getMissingArgumentDescriber = (version: TlcVersion | undefined) =>
|
|
318
323
|
version === "1.7.4"
|
|
319
324
|
? (functionValue: Value, argument: Value) =>
|
|
@@ -330,41 +335,36 @@ export const getDomainOperator = (expression: Expression) => (value: Value) => {
|
|
|
330
335
|
};
|
|
331
336
|
|
|
332
337
|
export const getSubsetOperator =
|
|
333
|
-
(expression: Expression,
|
|
338
|
+
(expression: Expression, subset: (left: Value, right: Value) => Value) =>
|
|
339
|
+
(left: Value, right: Value) => {
|
|
334
340
|
if (!isSetValue(left) || isOverriddenSet(left)) {
|
|
335
341
|
throw new TlaEvaluationError(
|
|
336
342
|
`Attempted to evaluate an expression of form S \\subseteq T, but S was not enumerable.\n${describeRange(expression)}`,
|
|
337
343
|
);
|
|
338
344
|
}
|
|
339
|
-
return
|
|
345
|
+
return subset(left, right);
|
|
340
346
|
};
|
|
341
347
|
|
|
342
|
-
// TLC rejects a decimal, or an integer literal too big for it, while it processes the spec.
|
|
343
348
|
export const createRealNumberError = (expression: DecimalExpression) =>
|
|
344
349
|
setExitCode(
|
|
345
|
-
new TlaEvaluationError(
|
|
346
|
-
`TLC can't handle real numbers: ${expression.text} at ${describeLocation(expression)}`,
|
|
347
|
-
),
|
|
350
|
+
new TlaEvaluationError(`TLC can't handle real numbers.\n${expression.text}`),
|
|
348
351
|
EXIT_STATUS.configParseError,
|
|
349
352
|
);
|
|
350
353
|
|
|
351
354
|
export const createBigNumberError = (expression: NumberExpression) =>
|
|
352
355
|
setExitCode(
|
|
353
356
|
new TlaEvaluationError(
|
|
354
|
-
`TLC can't handle a number this big
|
|
357
|
+
`TLC can't handle a number this big.\n${expression.text ?? expression.value}`,
|
|
355
358
|
),
|
|
356
359
|
EXIT_STATUS.error,
|
|
357
360
|
);
|
|
358
361
|
|
|
359
|
-
// TLC's Tool#evalAppl fails to look up a variable the state doesn't assign.
|
|
360
362
|
export const createUnassignedError = (name: string, expression: Expression) =>
|
|
361
363
|
new TlaUnassignedError(
|
|
362
364
|
`In evaluation, the identifier ${name} is either undefined or not an operator.\n${describeRange(expression)}`,
|
|
363
365
|
name,
|
|
364
366
|
);
|
|
365
367
|
|
|
366
|
-
// TLC's Tool#enabled reads the subscript of <<A>>_v in the successor as a state of its own, and
|
|
367
|
-
// names the fairness condition when A leaves a variable of v unassigned, unlike TLC 1.7.4's.
|
|
368
368
|
export const toUnspecifiedSubscriptError = (error: unknown, version: TlcVersion | undefined) =>
|
|
369
369
|
error instanceof TlaUnassignedError && version !== "1.7.4"
|
|
370
370
|
? new TlaEvaluationError(
|
|
@@ -372,11 +372,6 @@ export const toUnspecifiedSubscriptError = (error: unknown, version: TlcVersion
|
|
|
372
372
|
)
|
|
373
373
|
: error;
|
|
374
374
|
|
|
375
|
-
export const createPrimeOutsideActionError = (expression: Expression) =>
|
|
376
|
-
new TlaEvaluationError(
|
|
377
|
-
`A primed expression appears outside an action at ${describeLocation(expression)}`,
|
|
378
|
-
);
|
|
379
|
-
|
|
380
375
|
export const lookupScope = (scope: Scope | undefined, name: string): Binding | undefined => {
|
|
381
376
|
for (let current = scope; current; current = current.parent) {
|
|
382
377
|
if (current.name === name) return current.binding;
|
|
@@ -390,12 +385,13 @@ export const bindValue = (scope: Scope | undefined, name: string, value: Value):
|
|
|
390
385
|
parent: scope,
|
|
391
386
|
});
|
|
392
387
|
|
|
393
|
-
const bindPattern = (scope: Scope | undefined, pattern: BoundPattern, value: Value) => {
|
|
388
|
+
export const bindPattern = (scope: Scope | undefined, pattern: BoundPattern, value: Value) => {
|
|
394
389
|
if (pattern.kind === "Name") return bindValue(scope, pattern.name, value);
|
|
395
390
|
const elements = getSequenceElements(value);
|
|
396
391
|
if (!elements || elements.length !== pattern.names.length) {
|
|
392
|
+
const range = pattern.ranges?.[0];
|
|
397
393
|
throw new TlaEvaluationError(
|
|
398
|
-
`
|
|
394
|
+
`Argument mismatch in operator application.${range ? formatRange(range) : ""}`,
|
|
399
395
|
);
|
|
400
396
|
}
|
|
401
397
|
return pattern.names.reduce<Scope | undefined>(
|
|
@@ -404,7 +400,6 @@ const bindPattern = (scope: Scope | undefined, pattern: BoundPattern, value: Val
|
|
|
404
400
|
);
|
|
405
401
|
};
|
|
406
402
|
|
|
407
|
-
// Tool#evalAppl checks that it applies a function before it evaluates the argument.
|
|
408
403
|
export const expectFunction = (value: Value, application: Expression) => {
|
|
409
404
|
if (isFunctionValue(value)) return value;
|
|
410
405
|
throw new TlaEvaluationError(
|
|
@@ -440,6 +435,42 @@ export const expectBoolean = (value: Value, description: string) => {
|
|
|
440
435
|
return value;
|
|
441
436
|
};
|
|
442
437
|
|
|
438
|
+
export const expectImplication = (value: Value, expression: Expression, side: "P" | "Q") => {
|
|
439
|
+
if (typeof value !== "boolean") {
|
|
440
|
+
throw new TlaEvaluationError(
|
|
441
|
+
`Attempted to evaluate an expression of form P => Q when ${side} was\n${getKindString(value)}.\n${describeRange(expression)}`,
|
|
442
|
+
);
|
|
443
|
+
}
|
|
444
|
+
return value;
|
|
445
|
+
};
|
|
446
|
+
|
|
447
|
+
export const negate = (value: Value, expression: Expression) => {
|
|
448
|
+
if (typeof value !== "boolean") {
|
|
449
|
+
throw new TlaEvaluationError(
|
|
450
|
+
`Attempted to apply the operator ~ to a non-boolean\n(${getKindString(value)})\n${describeRange(expression)}`,
|
|
451
|
+
);
|
|
452
|
+
}
|
|
453
|
+
return !value;
|
|
454
|
+
};
|
|
455
|
+
|
|
456
|
+
export const isEquivalent = (left: Value, right: Value, expression: Expression) => {
|
|
457
|
+
if (typeof left !== "boolean" || typeof right !== "boolean") {
|
|
458
|
+
throw new TlaEvaluationError(
|
|
459
|
+
`Attempted to evaluate an expression of form P <=> Q when P or Q was not a boolean.\n${describeRange(expression)}`,
|
|
460
|
+
);
|
|
461
|
+
}
|
|
462
|
+
return left === right;
|
|
463
|
+
};
|
|
464
|
+
|
|
465
|
+
export const expectBooleanBody = (value: Value, expression: Expression) => {
|
|
466
|
+
if (typeof value !== "boolean") {
|
|
467
|
+
throw new TlaEvaluationError(
|
|
468
|
+
`TLC expected a boolean value, but did not find one. ${describeNode(expression)}`,
|
|
469
|
+
);
|
|
470
|
+
}
|
|
471
|
+
return value;
|
|
472
|
+
};
|
|
473
|
+
|
|
443
474
|
export const getDefinition = (name: string, environment: Environment) =>
|
|
444
475
|
environment.definitions.get(environment.substitutions.get(name) ?? name);
|
|
445
476
|
|
|
@@ -459,12 +490,9 @@ const getBoundExplanation = (set: Value, text: string) => {
|
|
|
459
490
|
return undefined;
|
|
460
491
|
};
|
|
461
492
|
|
|
462
|
-
// TLC enumerates every set except the ones it implements in Java, so any other set fails as its own
|
|
463
|
-
// class does.
|
|
464
493
|
const checkEnumerable = (set: Value, expression: Expression, version: TlcVersion) => {
|
|
465
494
|
if (!isSetValue(set) || isOverriddenSet(set)) {
|
|
466
495
|
const text = formatValue(set);
|
|
467
|
-
// TLC 1.7.4 doesn't explain why it can't enumerate a set.
|
|
468
496
|
const explanation = version === "1.7.4" ? undefined : getBoundExplanation(set, text);
|
|
469
497
|
throw new TlaEvaluationError(
|
|
470
498
|
explanation === undefined
|
|
@@ -480,16 +508,12 @@ const getEnumeratedElements = (set: Value, expression: Expression, version: TlcV
|
|
|
480
508
|
return getLazySubsets(set) ?? getNormalizedSetElements(set);
|
|
481
509
|
};
|
|
482
510
|
|
|
483
|
-
// The elements Tool.contexts binds to the bound of a quantifier or a set map. TLC 1.7.4 streams a
|
|
484
|
-
// lazy set's elements, where later versions normalize the set first.
|
|
485
511
|
export const getContextElements = (set: Value, expression: Expression, version: TlcVersion) => {
|
|
486
512
|
if (version !== "1.7.4") return getEnumeratedElements(set, expression, version);
|
|
487
513
|
checkEnumerable(set, expression, version);
|
|
488
514
|
return getLazySubsets(set) ?? getStreamedElements(set);
|
|
489
515
|
};
|
|
490
516
|
|
|
491
|
-
// Like TLC, a quantifier keeps an interval as an interval, so that it can stop at the first witness
|
|
492
|
-
// in a large interval such as 1..2000000000 without listing it.
|
|
493
517
|
const getKeptInterval = (set: Value) => {
|
|
494
518
|
if (typeof set !== "object" || set.kind !== "Interval") return undefined;
|
|
495
519
|
getCardinality(set);
|
|
@@ -499,7 +523,6 @@ const getKeptInterval = (set: Value) => {
|
|
|
499
523
|
export const getQuantifierElements = (set: Value, expression: Expression, version: TlcVersion) =>
|
|
500
524
|
getKeptInterval(set) ?? getContextElements(set, expression, version);
|
|
501
525
|
|
|
502
|
-
// CHOOSE and a function constructor visit the elements of the normalized set.
|
|
503
526
|
const getNormalizedElements = (set: Value, expression: Expression, version: TlcVersion) =>
|
|
504
527
|
getKeptInterval(set) ?? getEnumeratedElements(set, expression, version);
|
|
505
528
|
|
|
@@ -514,16 +537,22 @@ const someElement = (
|
|
|
514
537
|
return false;
|
|
515
538
|
};
|
|
516
539
|
|
|
540
|
+
export const mapBoundSets = <Result>(
|
|
541
|
+
bounds: Bound[],
|
|
542
|
+
map: (set: Expression, index: number) => Result,
|
|
543
|
+
) =>
|
|
544
|
+
bounds.reduce<Result[]>((results, bound, index) => {
|
|
545
|
+
results.push(
|
|
546
|
+
index > 0 && bounds[index - 1].set === bound.set ? results[index - 1] : map(bound.set, index),
|
|
547
|
+
);
|
|
548
|
+
return results;
|
|
549
|
+
}, []);
|
|
550
|
+
|
|
517
551
|
export const getBoundElements = (bounds: Bound[], context: Context) =>
|
|
518
|
-
bounds
|
|
519
|
-
getQuantifierElements(
|
|
520
|
-
evaluate(bound.set, context),
|
|
521
|
-
bound.set,
|
|
522
|
-
context.environment.runtime.version,
|
|
523
|
-
),
|
|
552
|
+
mapBoundSets(bounds, (set) =>
|
|
553
|
+
getQuantifierElements(evaluate(set, context), set, context.environment.runtime.version),
|
|
524
554
|
);
|
|
525
555
|
|
|
526
|
-
// Visits each binding of the bounds to the elements of their sets, until visit returns true.
|
|
527
556
|
export const forEachBoundElement = (
|
|
528
557
|
bounds: Bound[],
|
|
529
558
|
sets: ReturnType<typeof getBoundElements>,
|
|
@@ -545,8 +574,33 @@ export const forEachBinding = (
|
|
|
545
574
|
visit: (scope: Scope | undefined) => boolean,
|
|
546
575
|
) => forEachBoundElement(bounds, getBoundElements(bounds, context), context.scope, visit);
|
|
547
576
|
|
|
577
|
+
const forEachChargedBinding = (
|
|
578
|
+
bounds: Bound[],
|
|
579
|
+
context: Context,
|
|
580
|
+
coverage: Coverage,
|
|
581
|
+
visit: (scope: Scope | undefined) => boolean,
|
|
582
|
+
) => {
|
|
583
|
+
const bounded = mapBoundSets(bounds, (set) => {
|
|
584
|
+
const value = evaluate(set, context);
|
|
585
|
+
return {
|
|
586
|
+
value,
|
|
587
|
+
elements: getQuantifierElements(value, set, context.environment.runtime.version),
|
|
588
|
+
};
|
|
589
|
+
});
|
|
590
|
+
const sets = bounded.map((item) => item.elements);
|
|
591
|
+
const charge = chargeContexts(
|
|
592
|
+
coverage,
|
|
593
|
+
bounded.map((item) => item.value),
|
|
594
|
+
sets,
|
|
595
|
+
);
|
|
596
|
+
return forEachBoundElement(bounds, sets, context.scope, (scope) => {
|
|
597
|
+
charge();
|
|
598
|
+
return visit(scope);
|
|
599
|
+
});
|
|
600
|
+
};
|
|
601
|
+
|
|
548
602
|
const getBoundsDomain = (bounds: Bound[], context: Context): Value => {
|
|
549
|
-
const sets = bounds
|
|
603
|
+
const sets = mapBoundSets(bounds, (set) => evaluate(set, context));
|
|
550
604
|
return sets.length === 1 ? sets[0] : { kind: "ProductSet", factors: sets };
|
|
551
605
|
};
|
|
552
606
|
|
|
@@ -559,8 +613,6 @@ const bindArgument = (bounds: Bound[], scope: Scope | undefined, argument: Value
|
|
|
559
613
|
);
|
|
560
614
|
};
|
|
561
615
|
|
|
562
|
-
// The parameters, body and scope of each function a constructor or a definition keeps lazy, whose
|
|
563
|
-
// body TLC's getInitStates and getNextStates walk for an argument, as they do a FcnLambdaValue's.
|
|
564
616
|
interface LazyFunction {
|
|
565
617
|
value: LazyFunctionValue;
|
|
566
618
|
bounds: Bound[];
|
|
@@ -568,8 +620,7 @@ interface LazyFunction {
|
|
|
568
620
|
scope: Scope | undefined;
|
|
569
621
|
}
|
|
570
622
|
|
|
571
|
-
//
|
|
572
|
-
// short-lived function makes every garbage collection slower.
|
|
623
|
+
// Kept on the value itself, since a WeakMap entry per short-lived function slows every GC.
|
|
573
624
|
interface KeptLazyFunctionValue extends LazyFunctionValue {
|
|
574
625
|
lambda: LazyFunction;
|
|
575
626
|
}
|
|
@@ -582,8 +633,6 @@ const keepLambda = (lambda: LazyFunction) => Object.assign(lambda.value, { lambd
|
|
|
582
633
|
export const getLazyFunction = (value: Value) =>
|
|
583
634
|
isKeptLazyFunction(value) ? value.lambda : undefined;
|
|
584
635
|
|
|
585
|
-
// Tool.getFcnContext: the scope of a lazy function's body for the arguments of an application. It
|
|
586
|
-
// ignores arguments beyond the parameters.
|
|
587
636
|
export const bindLazyArguments = (
|
|
588
637
|
lambda: LazyFunction,
|
|
589
638
|
expression: Expression & { kind: "FunctionApplication" },
|
|
@@ -608,12 +657,18 @@ export const bindLazyArguments = (
|
|
|
608
657
|
typeof value.domain === "object" && value.domain.kind === "ProductSet"
|
|
609
658
|
? value.domain.factors
|
|
610
659
|
: [];
|
|
611
|
-
if (elements === undefined
|
|
660
|
+
if (elements === undefined) {
|
|
612
661
|
throw new TlaEvaluationError(
|
|
613
662
|
`Attempted to apply a function to an argument not in its domain.\n${describeRange(expression.function)}`,
|
|
614
663
|
);
|
|
615
664
|
}
|
|
665
|
+
// Deviation from TLC: Tool#getFcnContext indexes past an argument tuple shorter than the bounds and ignores a longer one.
|
|
666
|
+
const createListError = () =>
|
|
667
|
+
new TlaEvaluationError(
|
|
668
|
+
`In applying the function\n${prettyPrint(formatValue(value))},\nthe argument list is:\n${prettyPrint(formatValue(argument))}\nwhich does not match its formal parameter.\n`,
|
|
669
|
+
);
|
|
616
670
|
bounds.forEach((bound, index) => {
|
|
671
|
+
if (index >= elements.length) throw createListError();
|
|
617
672
|
const element = elements[index];
|
|
618
673
|
const ordinal = `argument number ${index + 1}`;
|
|
619
674
|
if (!isElementOf(element, domains[index])) {
|
|
@@ -634,11 +689,10 @@ export const bindLazyArguments = (
|
|
|
634
689
|
);
|
|
635
690
|
}
|
|
636
691
|
});
|
|
637
|
-
|
|
692
|
+
if (elements.length > bounds.length) throw createListError();
|
|
693
|
+
return bindArgument(bounds, lambda.scope, argument);
|
|
638
694
|
};
|
|
639
695
|
|
|
640
|
-
// TLC prints a function it can't enumerate as its parameters and the location of its body. It
|
|
641
|
-
// prints only the first name of a group such as `m, n \in S`.
|
|
642
696
|
interface LazyFunctionTemplate {
|
|
643
697
|
parameters: { index: number; name: string }[];
|
|
644
698
|
body: string;
|
|
@@ -661,7 +715,7 @@ const getLazyFunctionTemplate = (bounds: Bound[], body: Expression) => {
|
|
|
661
715
|
},
|
|
662
716
|
],
|
|
663
717
|
),
|
|
664
|
-
body:
|
|
718
|
+
body: describeNode(body),
|
|
665
719
|
};
|
|
666
720
|
};
|
|
667
721
|
|
|
@@ -684,22 +738,29 @@ const getLazyFunctionSource = (
|
|
|
684
738
|
};
|
|
685
739
|
};
|
|
686
740
|
|
|
687
|
-
// TLC's FcnLambdaValue evaluates its body at each application.
|
|
688
741
|
const createLazyFunction = (
|
|
689
742
|
domain: Value,
|
|
690
743
|
compute: (argument: Value, self: LazyFunctionValue) => Value,
|
|
691
744
|
source: LazyFunctionSource | undefined,
|
|
745
|
+
boundTupleLengths: (number | undefined)[] | undefined,
|
|
692
746
|
) => {
|
|
693
747
|
const self: LazyFunctionValue = {
|
|
694
748
|
kind: "LazyFunction",
|
|
695
749
|
domain,
|
|
696
750
|
source,
|
|
751
|
+
boundTupleLengths,
|
|
697
752
|
apply: (argument) => compute(argument, self),
|
|
698
753
|
};
|
|
699
754
|
return self;
|
|
700
755
|
};
|
|
701
756
|
|
|
702
|
-
|
|
757
|
+
const getBoundTupleLengths = (bounds: Bound[]) =>
|
|
758
|
+
bounds.length === 1
|
|
759
|
+
? undefined
|
|
760
|
+
: bounds.map((bound) =>
|
|
761
|
+
bound.pattern.kind === "Tuple" ? bound.pattern.names.length : undefined,
|
|
762
|
+
);
|
|
763
|
+
|
|
703
764
|
const getDefinitionSource = (definition: FunctionDefinition): Expression => ({
|
|
704
765
|
kind: "FunctionConstruction",
|
|
705
766
|
bounds: definition.bounds,
|
|
@@ -707,7 +768,10 @@ const getDefinitionSource = (definition: FunctionDefinition): Expression => ({
|
|
|
707
768
|
location: definition.location,
|
|
708
769
|
});
|
|
709
770
|
|
|
710
|
-
const createRecursiveFunction = (
|
|
771
|
+
const createRecursiveFunction = (
|
|
772
|
+
definition: FunctionDefinition,
|
|
773
|
+
context: Context,
|
|
774
|
+
): RebindableLazyFunction => {
|
|
711
775
|
const domain = getBoundsDomain(definition.bounds, context);
|
|
712
776
|
const functionValue = createLazyFunction(
|
|
713
777
|
domain,
|
|
@@ -724,6 +788,7 @@ const createRecursiveFunction = (definition: FunctionDefinition, context: Contex
|
|
|
724
788
|
definition.bounds,
|
|
725
789
|
domain,
|
|
726
790
|
),
|
|
791
|
+
getBoundTupleLengths(definition.bounds),
|
|
727
792
|
);
|
|
728
793
|
keepLambda({
|
|
729
794
|
value: functionValue,
|
|
@@ -731,11 +796,16 @@ const createRecursiveFunction = (definition: FunctionDefinition, context: Contex
|
|
|
731
796
|
body: definition.body,
|
|
732
797
|
scope: bindValue(undefined, definition.name, functionValue),
|
|
733
798
|
});
|
|
734
|
-
|
|
799
|
+
const rebindable: RebindableLazyFunction = Object.assign(functionValue, {
|
|
800
|
+
rebind: (tracing: Environment) => {
|
|
801
|
+
const rebound = createRecursiveFunction(definition, { ...context, environment: tracing });
|
|
802
|
+
rebound.enumerated = functionValue.enumerated;
|
|
803
|
+
return rebound;
|
|
804
|
+
},
|
|
805
|
+
});
|
|
806
|
+
return definition.bounds.length === 1 ? markLambdaFunction(rebindable) : rebindable;
|
|
735
807
|
};
|
|
736
808
|
|
|
737
|
-
// TLC computes a constant definition when it starts, without keeping a function it constructs
|
|
738
|
-
// lazy, so a function over an interval or an enumerated set is a FcnRcdValue.
|
|
739
809
|
const toStartupValue = (definition: Definition, value: Value): Value => {
|
|
740
810
|
if (typeof value !== "object" || getFunctionClass(value) !== "lambda") return value;
|
|
741
811
|
if (
|
|
@@ -750,14 +820,11 @@ const toStartupValue = (definition: Definition, value: Value): Value => {
|
|
|
750
820
|
const finite = toFiniteFunction(value);
|
|
751
821
|
return createSortedFunction(finite.domain, finite.range);
|
|
752
822
|
} catch (error) {
|
|
753
|
-
// TLC leaves a definition it fails to compute to evaluate where the spec uses it.
|
|
754
823
|
if (error instanceof TlaEvaluationError) return value;
|
|
755
824
|
throw error;
|
|
756
825
|
}
|
|
757
826
|
};
|
|
758
827
|
|
|
759
|
-
// The code of a definition's body, evaluated as a whole. TLC evaluates a function definition that
|
|
760
|
-
// isn't recursive as it does a function constructor.
|
|
761
828
|
const compileDefinitionBody = (definition: Definition, environment: Environment): Evaluator => {
|
|
762
829
|
if (definition.kind === "Operator" && definition.params.length > 0) {
|
|
763
830
|
return () => {
|
|
@@ -772,59 +839,100 @@ const compileDefinitionBody = (definition: Definition, environment: Environment)
|
|
|
772
839
|
return getEntryEvaluator(getDefinitionSource(definition), environment);
|
|
773
840
|
};
|
|
774
841
|
|
|
775
|
-
|
|
776
|
-
|
|
842
|
+
const CALLER_SCOPE: Scope = {
|
|
843
|
+
name: "",
|
|
844
|
+
binding: { kind: "Value", value: false },
|
|
845
|
+
parent: undefined,
|
|
846
|
+
};
|
|
847
|
+
|
|
777
848
|
const getDefinitionEvaluator = (definition: Definition, environment: Environment): Evaluator => {
|
|
778
849
|
const compiled = environment.definitionEvaluators.get(definition);
|
|
779
850
|
if (compiled) return compiled;
|
|
780
851
|
const body = compileDefinitionBody(definition, environment);
|
|
781
|
-
const
|
|
852
|
+
const definitionId = environment.facts.ids.get(definition);
|
|
782
853
|
const startupValues = environment.startupValues;
|
|
783
|
-
const
|
|
784
|
-
|
|
854
|
+
const isInCallerContext =
|
|
855
|
+
definition.kind === "Operator" &&
|
|
856
|
+
definition.params.length === 0 &&
|
|
857
|
+
isTlcEvalReached(definition.body, environment);
|
|
858
|
+
const evaluator: Evaluator = isInCallerContext
|
|
859
|
+
? (context) =>
|
|
860
|
+
(definitionId === undefined ? undefined : startupValues[definitionId]) ??
|
|
861
|
+
body(withScope(context, isTlcContextEmpty(context.scope) ? undefined : CALLER_SCOPE))
|
|
862
|
+
: definitionId === undefined
|
|
785
863
|
? (context) => body(withScope(context, undefined))
|
|
786
|
-
: (context) => startupValues[
|
|
864
|
+
: (context) => startupValues[definitionId] ?? body(withScope(context, undefined));
|
|
787
865
|
environment.definitionEvaluators.set(definition, evaluator);
|
|
788
866
|
return evaluator;
|
|
789
867
|
};
|
|
790
868
|
|
|
791
869
|
export const getStartupValue = (definition: Definition, environment: Environment) => {
|
|
792
|
-
const
|
|
793
|
-
return
|
|
870
|
+
const definitionId = environment.facts.ids.get(definition);
|
|
871
|
+
return definitionId === undefined ? undefined : environment.startupValues[definitionId];
|
|
794
872
|
};
|
|
795
873
|
|
|
796
|
-
// TLC computes each constant definition the configuration doesn't replace when it starts, and
|
|
797
|
-
// leaves one it fails to compute to evaluate where the spec uses it.
|
|
798
874
|
export const evaluateStartupDefinitions = (definitions: Definition[], environment: Environment) =>
|
|
799
875
|
definitions.forEach((definition) => {
|
|
800
876
|
if (definition.kind === "Operator" && definition.params.length > 0) return;
|
|
801
877
|
const name = definition.name;
|
|
802
878
|
if (environment.constants.has(name) || environment.substitutions.has(name)) return;
|
|
803
|
-
if (!
|
|
804
|
-
const
|
|
805
|
-
if (
|
|
879
|
+
if (!isEvaluatedAtStartup(definition, environment)) return;
|
|
880
|
+
const definitionId = environment.facts.ids.get(definition);
|
|
881
|
+
if (definitionId === undefined || environment.startupValues[definitionId] !== undefined) return;
|
|
806
882
|
const context = { environment, scope: undefined, state: undefined, next: undefined };
|
|
807
883
|
try {
|
|
808
884
|
const value = environment.runtime.evaluateAtStartup(() =>
|
|
809
885
|
toStartupValue(definition, compileDefinitionBody(definition, environment)(context)),
|
|
810
886
|
);
|
|
811
887
|
markNormalized(value);
|
|
812
|
-
environment.startupValues[
|
|
888
|
+
environment.startupValues[definitionId] = value;
|
|
813
889
|
} catch (error) {
|
|
814
890
|
// TLC swallows whatever the definition throws, a stack overflow included.
|
|
815
891
|
if (!(error instanceof TlaEvaluationError) && !isStackOverflow(error)) throw error;
|
|
816
892
|
}
|
|
817
893
|
});
|
|
818
894
|
|
|
895
|
+
const isStateWithin = (state: State | undefined, cached: State | undefined) => {
|
|
896
|
+
if (cached === undefined || state === cached) return true;
|
|
897
|
+
try {
|
|
898
|
+
return cached.every(
|
|
899
|
+
(value, index) =>
|
|
900
|
+
value === undefined || (state?.[index] !== undefined && valuesEqual(state[index], value)),
|
|
901
|
+
);
|
|
902
|
+
} catch (error) {
|
|
903
|
+
if (error instanceof TlaEvaluationError) return false;
|
|
904
|
+
throw error;
|
|
905
|
+
}
|
|
906
|
+
};
|
|
907
|
+
|
|
819
908
|
const forceThunk = (thunk: Thunk, context: Context) => {
|
|
820
|
-
const
|
|
821
|
-
|
|
822
|
-
|
|
823
|
-
|
|
909
|
+
const cache = thunk.cache;
|
|
910
|
+
const isCached =
|
|
911
|
+
cache !== undefined &&
|
|
912
|
+
isStateWithin(context.state, thunk.state) &&
|
|
913
|
+
isStateWithin(context.next, thunk.next);
|
|
914
|
+
if (isCached) return cache;
|
|
915
|
+
const coverage = context.environment.coverage;
|
|
916
|
+
const node = coverage?.current === -1 ? undefined : coverage?.values.get(thunk);
|
|
917
|
+
const value =
|
|
918
|
+
coverage && node !== undefined
|
|
919
|
+
? runAtCoverageNode(coverage, node, () =>
|
|
920
|
+
evaluate(thunk.expression, withScope(context, thunk.scope)),
|
|
921
|
+
)
|
|
922
|
+
: evaluate(thunk.expression, withScope(context, thunk.scope));
|
|
923
|
+
if (!thunk.isStreamed || isSettledValue(value)) {
|
|
924
|
+
thunk.cache = value;
|
|
925
|
+
thunk.state = context.state;
|
|
926
|
+
thunk.next = context.next;
|
|
927
|
+
}
|
|
928
|
+
if (thunk.cache !== undefined && thunk.state === undefined && thunk.next === undefined) {
|
|
929
|
+
thunk.scope = undefined;
|
|
930
|
+
thunk.isReleased = true;
|
|
931
|
+
}
|
|
824
932
|
return value;
|
|
825
933
|
};
|
|
826
934
|
|
|
827
|
-
const getDefinitionClosure = (definition: Definition & { kind: "Operator" }): Closure => ({
|
|
935
|
+
export const getDefinitionClosure = (definition: Definition & { kind: "Operator" }): Closure => ({
|
|
828
936
|
kind: "Closure",
|
|
829
937
|
name: definition.name,
|
|
830
938
|
params: definition.params,
|
|
@@ -888,6 +996,12 @@ const evaluateOperatorArgument = (expression: Expression, context: Context): Ope
|
|
|
888
996
|
};
|
|
889
997
|
|
|
890
998
|
const callOperatorWithValues = (operator: Operator, args: Value[], context: Context): Value => {
|
|
999
|
+
if (operator.kind === "Builtin" && operator.isLazy) {
|
|
1000
|
+
return operator.evaluate(
|
|
1001
|
+
args.map((value) => ({ kind: "Operator", name: "argument", arity: 0, call: () => value })),
|
|
1002
|
+
context,
|
|
1003
|
+
);
|
|
1004
|
+
}
|
|
891
1005
|
if (operator.kind === "Builtin") return operator.evaluate(args, context);
|
|
892
1006
|
if (operator.kind === "Operator") return operator.call(args);
|
|
893
1007
|
const scope = operator.params.reduce<Scope | undefined>(
|
|
@@ -905,11 +1019,6 @@ const toOperatorValue = (operator: Operator, context: Context): OperatorValue =>
|
|
|
905
1019
|
name: operator.name,
|
|
906
1020
|
arity: getArity(operator),
|
|
907
1021
|
call: (args) => callOperatorWithValues(operator, args, context),
|
|
908
|
-
literalBody:
|
|
909
|
-
operator.kind === "Closure" &&
|
|
910
|
-
(operator.body.kind === "Number" || operator.body.kind === "String")
|
|
911
|
-
? operator.body.value
|
|
912
|
-
: undefined,
|
|
913
1022
|
};
|
|
914
1023
|
|
|
915
1024
|
const isOperatorArgument = (expression: Expression, context: Context) => {
|
|
@@ -919,6 +1028,7 @@ const isOperatorArgument = (expression: Expression, context: Context) => {
|
|
|
919
1028
|
return operator !== undefined && getArity(operator) > 0;
|
|
920
1029
|
};
|
|
921
1030
|
|
|
1031
|
+
// Deviation from TLC: SymbolNodeValueLookupProvider#lookup takes an operator whose body is a literal for that literal, so a Java override rejects it as an argument.
|
|
922
1032
|
const evaluateBuiltinArguments = (args: Expression[], context: Context) =>
|
|
923
1033
|
args.map((arg) =>
|
|
924
1034
|
isOperatorArgument(arg, context)
|
|
@@ -961,9 +1071,17 @@ const compileArgumentBinder = (argument: Expression, environment: Environment):
|
|
|
961
1071
|
const isLiteral =
|
|
962
1072
|
argument.kind === "String" || (argument.kind === "Number" && isTlcInteger(argument.value));
|
|
963
1073
|
if (isLiteral) {
|
|
964
|
-
const binding: Binding = { kind: "Value", value: argument.value };
|
|
1074
|
+
const binding: Binding = { kind: "Value", value: argument.value, argument };
|
|
965
1075
|
return () => binding;
|
|
966
1076
|
}
|
|
1077
|
+
const coverage = environment.coverage;
|
|
1078
|
+
if (coverage) {
|
|
1079
|
+
return (context) => {
|
|
1080
|
+
const thunk = createThunk(argument, context);
|
|
1081
|
+
if (coverage.current !== -1) coverage.values.set(thunk, coverage.current);
|
|
1082
|
+
return thunk;
|
|
1083
|
+
};
|
|
1084
|
+
}
|
|
967
1085
|
if (argument.kind === "Identifier") {
|
|
968
1086
|
const global = isLocallyResolved(argument)
|
|
969
1087
|
? undefined
|
|
@@ -972,7 +1090,7 @@ const compileArgumentBinder = (argument: Expression, environment: Environment):
|
|
|
972
1090
|
const binding: Binding = { kind: "Value", value: global.value };
|
|
973
1091
|
return () => binding;
|
|
974
1092
|
}
|
|
975
|
-
if (global === undefined) {
|
|
1093
|
+
if (global === undefined && !environment.callStack) {
|
|
976
1094
|
return (context) => {
|
|
977
1095
|
const binding = lookupScope(context.scope, argument.name);
|
|
978
1096
|
return binding?.kind === "Value" || binding?.kind === "Thunk"
|
|
@@ -1020,65 +1138,90 @@ const callOperator = (
|
|
|
1020
1138
|
return operator.evaluate(evaluateBuiltinArguments(args, context), context);
|
|
1021
1139
|
};
|
|
1022
1140
|
|
|
1023
|
-
// The LET definitions that a reference evaluates again, and those that cache only a settled value.
|
|
1024
1141
|
interface ReevaluatedDefinitions {
|
|
1025
1142
|
impure: ReadonlySet<Definition>;
|
|
1026
1143
|
streamed: ReadonlySet<Definition>;
|
|
1027
1144
|
}
|
|
1028
1145
|
|
|
1146
|
+
const letFunctionConstructions = new WeakMap<FunctionDefinition, Expression>();
|
|
1147
|
+
|
|
1148
|
+
const getLetFunctionConstruction = (definition: FunctionDefinition): Expression => {
|
|
1149
|
+
const known = letFunctionConstructions.get(definition);
|
|
1150
|
+
if (known) return known;
|
|
1151
|
+
const construction: Expression = {
|
|
1152
|
+
kind: "FunctionConstruction",
|
|
1153
|
+
bounds: definition.bounds,
|
|
1154
|
+
body: definition.body,
|
|
1155
|
+
location: definition.location,
|
|
1156
|
+
isRecursive: true,
|
|
1157
|
+
};
|
|
1158
|
+
letFunctionConstructions.set(definition, construction);
|
|
1159
|
+
return construction;
|
|
1160
|
+
};
|
|
1161
|
+
|
|
1029
1162
|
export const bindDefinitions = (
|
|
1030
1163
|
definitions: Definition[],
|
|
1031
1164
|
context: Context,
|
|
1032
1165
|
reevaluated?: ReevaluatedDefinitions,
|
|
1033
|
-
): Scope | undefined =>
|
|
1034
|
-
definitions.
|
|
1035
|
-
|
|
1036
|
-
|
|
1037
|
-
|
|
1038
|
-
|
|
1039
|
-
|
|
1040
|
-
|
|
1041
|
-
node.binding = {
|
|
1042
|
-
kind: "Thunk",
|
|
1043
|
-
expression: {
|
|
1044
|
-
kind: "FunctionConstruction",
|
|
1045
|
-
bounds: definition.bounds,
|
|
1046
|
-
body: definition.body,
|
|
1047
|
-
location: definition.location,
|
|
1048
|
-
isRecursive: true,
|
|
1049
|
-
},
|
|
1050
|
-
scope: node,
|
|
1051
|
-
state: context.state,
|
|
1052
|
-
next: context.next,
|
|
1053
|
-
cache: undefined,
|
|
1054
|
-
isStreamed: false,
|
|
1055
|
-
};
|
|
1056
|
-
return node;
|
|
1057
|
-
}
|
|
1058
|
-
if (definition.params.length > 0 || reevaluated?.impure.has(definition)) {
|
|
1059
|
-
node.binding = {
|
|
1060
|
-
kind: "Operator",
|
|
1061
|
-
operator: {
|
|
1062
|
-
kind: "Closure",
|
|
1063
|
-
name: definition.name,
|
|
1064
|
-
params: definition.params,
|
|
1065
|
-
body: definition.body,
|
|
1066
|
-
scope: node,
|
|
1067
|
-
},
|
|
1068
|
-
};
|
|
1069
|
-
return node;
|
|
1070
|
-
}
|
|
1071
|
-
node.binding = {
|
|
1072
|
-
kind: "Thunk",
|
|
1073
|
-
expression: definition.body,
|
|
1074
|
-
scope: node,
|
|
1075
|
-
state: context.state,
|
|
1076
|
-
next: context.next,
|
|
1077
|
-
cache: undefined,
|
|
1078
|
-
isStreamed: reevaluated?.streamed.has(definition) ?? false,
|
|
1079
|
-
};
|
|
1166
|
+
): Scope | undefined => {
|
|
1167
|
+
const nodes = definitions.map((definition): Scope => ({
|
|
1168
|
+
name: definition.name,
|
|
1169
|
+
binding: { kind: "Value", value: false },
|
|
1170
|
+
parent: undefined,
|
|
1171
|
+
}));
|
|
1172
|
+
const scope = nodes.reduce<Scope | undefined>((parent, node) => {
|
|
1173
|
+
node.parent = parent;
|
|
1080
1174
|
return node;
|
|
1081
1175
|
}, context.scope);
|
|
1176
|
+
let isRecursiveAtOrAfter = false;
|
|
1177
|
+
for (let index = definitions.length - 1; index >= 0; index--) {
|
|
1178
|
+
const definition = definitions[index];
|
|
1179
|
+
isRecursiveAtOrAfter ||= definition.isRecursive;
|
|
1180
|
+
// TLC's LET evaluates an operator without parameters in the context before it, which TLCEval#tlcEval tells from an empty one.
|
|
1181
|
+
const ownScope =
|
|
1182
|
+
definition.kind === "Operator" && definition.params.length === 0 && !isRecursiveAtOrAfter
|
|
1183
|
+
? nodes[index].parent
|
|
1184
|
+
: scope;
|
|
1185
|
+
nodes[index].binding =
|
|
1186
|
+
definition.kind === "Function"
|
|
1187
|
+
? {
|
|
1188
|
+
kind: "Thunk",
|
|
1189
|
+
expression: getLetFunctionConstruction(definition),
|
|
1190
|
+
scope,
|
|
1191
|
+
state: context.state,
|
|
1192
|
+
next: context.next,
|
|
1193
|
+
cache: undefined,
|
|
1194
|
+
isStreamed: false,
|
|
1195
|
+
}
|
|
1196
|
+
: definition.params.length > 0 || reevaluated?.impure.has(definition)
|
|
1197
|
+
? {
|
|
1198
|
+
kind: "Operator",
|
|
1199
|
+
operator: {
|
|
1200
|
+
kind: "Closure",
|
|
1201
|
+
name: definition.name,
|
|
1202
|
+
params: definition.params,
|
|
1203
|
+
body: definition.body,
|
|
1204
|
+
scope: ownScope,
|
|
1205
|
+
},
|
|
1206
|
+
}
|
|
1207
|
+
: {
|
|
1208
|
+
kind: "Thunk",
|
|
1209
|
+
expression: definition.body,
|
|
1210
|
+
scope: ownScope,
|
|
1211
|
+
state: context.state,
|
|
1212
|
+
next: context.next,
|
|
1213
|
+
cache: undefined,
|
|
1214
|
+
isStreamed: reevaluated?.streamed.has(definition) ?? false,
|
|
1215
|
+
};
|
|
1216
|
+
}
|
|
1217
|
+
const coverage = context.environment.coverage;
|
|
1218
|
+
if (coverage && coverage.current !== -1) {
|
|
1219
|
+
nodes.forEach((node) => {
|
|
1220
|
+
if (node.binding.kind === "Thunk") coverage.values.set(node.binding, coverage.current);
|
|
1221
|
+
});
|
|
1222
|
+
}
|
|
1223
|
+
return scope;
|
|
1224
|
+
};
|
|
1082
1225
|
|
|
1083
1226
|
const evaluateLocalIdentifier = (name: string, expression: Expression, context: Context): Value => {
|
|
1084
1227
|
const binding = lookupScope(context.scope, name);
|
|
@@ -1100,19 +1243,22 @@ const evaluateLocalIdentifier = (name: string, expression: Expression, context:
|
|
|
1100
1243
|
if (global?.kind === "Definition") {
|
|
1101
1244
|
return getDefinitionEvaluator(global.definition, context.environment)(context);
|
|
1102
1245
|
}
|
|
1103
|
-
const builtin = context.environment.builtins.get(
|
|
1246
|
+
const builtin = context.environment.builtins.get(
|
|
1247
|
+
context.environment.substitutions.get(name) ?? name,
|
|
1248
|
+
);
|
|
1104
1249
|
if (builtin?.arity === 0) return builtin.evaluate([], context);
|
|
1105
|
-
throw new TlaEvaluationError(
|
|
1250
|
+
throw new TlaEvaluationError(
|
|
1251
|
+
`In evaluation, the identifier ${name} is either undefined or not an operator.\n${describeRange(expression)}`,
|
|
1252
|
+
);
|
|
1106
1253
|
};
|
|
1107
1254
|
|
|
1108
|
-
// TLC's next-state generator does not bind LET definitions to values, so each reference to one
|
|
1109
|
-
// evaluates it again: one that calls an impure builtin repeats its effects, and a set one builds
|
|
1110
|
-
// with UNION or \cup starts out uncached.
|
|
1111
1255
|
export const getReevaluatedDefinitions = (
|
|
1112
1256
|
definitions: Definition[],
|
|
1113
1257
|
environment: Environment,
|
|
1114
1258
|
): ReevaluatedDefinitions => ({
|
|
1115
|
-
impure: new Set(
|
|
1259
|
+
impure: new Set(
|
|
1260
|
+
definitions.filter((definition) => isImpureDefinition(definition, environment, "varying")),
|
|
1261
|
+
),
|
|
1116
1262
|
streamed: new Set(
|
|
1117
1263
|
definitions.filter((definition) => isImpureDefinition(definition, environment, "streamed")),
|
|
1118
1264
|
),
|
|
@@ -1123,23 +1269,39 @@ export const isImpure = (environment: Environment) =>
|
|
|
1123
1269
|
isImpureDefinition(definition, environment),
|
|
1124
1270
|
);
|
|
1125
1271
|
|
|
1126
|
-
// Whether evaluating a definition again can show, such as by printing twice.
|
|
1127
1272
|
export const hasRepeatedEffects = (environment: Environment) =>
|
|
1128
1273
|
[...environment.facts.ids.keys()].some((definition) =>
|
|
1129
1274
|
isImpureDefinition(definition, environment, "repeated"),
|
|
1130
1275
|
);
|
|
1131
1276
|
|
|
1132
|
-
// A set filter TLC evaluates lazily, with how to rebuild it so that its predicate runs in another
|
|
1133
|
-
// environment.
|
|
1134
1277
|
interface RebindableFilteredSet extends FilteredSetValue {
|
|
1135
1278
|
rebind: (environment: Environment) => Value;
|
|
1136
1279
|
}
|
|
1137
1280
|
|
|
1138
|
-
|
|
1139
|
-
|
|
1281
|
+
interface RebindableLazyFunction extends LazyFunctionValue {
|
|
1282
|
+
rebind: (environment: Environment) => Value;
|
|
1283
|
+
}
|
|
1284
|
+
|
|
1285
|
+
const isRebindable = (value: Value): value is RebindableFilteredSet | RebindableLazyFunction =>
|
|
1286
|
+
typeof value === "object" &&
|
|
1287
|
+
(value.kind === "FilteredSet" || value.kind === "LazyFunction") &&
|
|
1288
|
+
"rebind" in value;
|
|
1289
|
+
|
|
1290
|
+
export const toNextContext = (context: Context): Context => ({
|
|
1291
|
+
environment: context.environment,
|
|
1292
|
+
scope: context.scope,
|
|
1293
|
+
state: context.next,
|
|
1294
|
+
next: undefined,
|
|
1295
|
+
isKeepLazy: context.isKeepLazy,
|
|
1296
|
+
});
|
|
1297
|
+
|
|
1298
|
+
const compileUnchanged =
|
|
1299
|
+
(evaluator: Evaluator): Evaluator =>
|
|
1300
|
+
(context) => {
|
|
1301
|
+
const current = evaluator(context);
|
|
1302
|
+
return valuesEqual(current, evaluator(toNextContext(context)));
|
|
1303
|
+
};
|
|
1140
1304
|
|
|
1141
|
-
// TLC's CallStackTool rebinds the lazy values its evaluations return, so their later evaluation
|
|
1142
|
-
// records its call stack too.
|
|
1143
1305
|
const traceEvaluator =
|
|
1144
1306
|
(
|
|
1145
1307
|
expression: Expression,
|
|
@@ -1157,13 +1319,17 @@ const traceEvaluator =
|
|
|
1157
1319
|
setTrace.callStack = callStack;
|
|
1158
1320
|
try {
|
|
1159
1321
|
const computed = evaluator(context);
|
|
1160
|
-
const value =
|
|
1322
|
+
const value = isRebindable(computed) ? computed.rebind(environment) : computed;
|
|
1161
1323
|
callStack.values.set(expression, value);
|
|
1162
1324
|
if (typeof value === "object" && value.kind !== "FilteredSet" && isSourced(expression)) {
|
|
1163
1325
|
callStack.sources.set(value, expression);
|
|
1164
1326
|
}
|
|
1165
1327
|
return value;
|
|
1166
1328
|
} catch (error) {
|
|
1329
|
+
if (error instanceof TlaSetBoundError && !callStack.isFrozen) {
|
|
1330
|
+
callStack.expressions.length = 0;
|
|
1331
|
+
callStack.isFrozen = true;
|
|
1332
|
+
}
|
|
1167
1333
|
const failed = error instanceof Error ? callStack.failures.get(error) : undefined;
|
|
1168
1334
|
if (error instanceof Error) callStack.failures.set(error, expression);
|
|
1169
1335
|
const receiver = getReceiver(expression, callStack.values);
|
|
@@ -1191,20 +1357,15 @@ const traceEvaluator =
|
|
|
1191
1357
|
}
|
|
1192
1358
|
};
|
|
1193
1359
|
|
|
1194
|
-
// A method of a value with a source raises a FingerprintException, which each value with a source
|
|
1195
|
-
// whose method called it heads in turn. CallStack#freeze adds their sources to the stack, outermost
|
|
1196
|
-
// first. The values are those whose methods failed, outermost first.
|
|
1197
1360
|
export const freezeCallStack = (
|
|
1198
1361
|
callStack: CallStack,
|
|
1199
1362
|
values: (Value | undefined)[],
|
|
1200
1363
|
error: unknown,
|
|
1201
1364
|
) => {
|
|
1202
|
-
// A set that streams its elements enumerates itself too, so it can appear twice.
|
|
1203
1365
|
const sources = [...new Set(values)].flatMap((item) => {
|
|
1204
1366
|
const source = typeof item === "object" ? callStack.sources.get(item) : undefined;
|
|
1205
1367
|
return source ? [source] : [];
|
|
1206
1368
|
});
|
|
1207
|
-
// A value with a source raises a FingerprintException even when the stack is frozen already.
|
|
1208
1369
|
if (sources.length > 0 && error instanceof TlaEvaluationError) {
|
|
1209
1370
|
if (!callStack.isFrozen) callStack.expressions.push(...sources);
|
|
1210
1371
|
const inner = callStack.fingerprint;
|
|
@@ -1216,8 +1377,6 @@ export const freezeCallStack = (
|
|
|
1216
1377
|
callStack.isFrozen = true;
|
|
1217
1378
|
};
|
|
1218
1379
|
|
|
1219
|
-
// A FingerprintException that a method of a value with a source raises, or that passes through one,
|
|
1220
|
-
// takes the value's source as its new head.
|
|
1221
1380
|
const headFingerprint = (callStack: CallStack, source: Expression, error: unknown) => {
|
|
1222
1381
|
if (!(error instanceof TlaEvaluationError)) return;
|
|
1223
1382
|
if (!callStack.isFrozen) callStack.expressions.push(source);
|
|
@@ -1229,8 +1388,6 @@ const headFingerprint = (callStack: CallStack, source: Expression, error: unknow
|
|
|
1229
1388
|
};
|
|
1230
1389
|
};
|
|
1231
1390
|
|
|
1232
|
-
// A copy of the environment that records the call stack of each evaluation, with evaluators of its
|
|
1233
|
-
// own since the environment's evaluators record nothing.
|
|
1234
1391
|
export const createTracingEnvironment = (environment: Environment): Environment => ({
|
|
1235
1392
|
...environment,
|
|
1236
1393
|
evaluators: new WeakMap(),
|
|
@@ -1245,20 +1402,107 @@ export const createTracingEnvironment = (environment: Environment): Environment
|
|
|
1245
1402
|
},
|
|
1246
1403
|
});
|
|
1247
1404
|
|
|
1405
|
+
// TLC evaluates `a /\ b /\ c` as `(a /\ b) /\ c`, so its call stack holds each prefix.
|
|
1406
|
+
const compileTracedJunction = (
|
|
1407
|
+
expression: Expression & { kind: "And" | "Or" },
|
|
1408
|
+
operands: Evaluator[],
|
|
1409
|
+
callStack: CallStack | undefined,
|
|
1410
|
+
): Evaluator | undefined => {
|
|
1411
|
+
const range = expression.location.range;
|
|
1412
|
+
const prefixEnds = expression.prefixEnds;
|
|
1413
|
+
if (!callStack || expression.isBulleted || !range || !prefixEnds || operands.length < 3) {
|
|
1414
|
+
return undefined;
|
|
1415
|
+
}
|
|
1416
|
+
const prefixes = prefixEnds
|
|
1417
|
+
.slice(0, operands.length - 2)
|
|
1418
|
+
.map((end) => ({
|
|
1419
|
+
...expression,
|
|
1420
|
+
location: { ...expression.location, range: { ...range, end } },
|
|
1421
|
+
}))
|
|
1422
|
+
.reverse();
|
|
1423
|
+
const isAnd = expression.kind === "And";
|
|
1424
|
+
return (context) => {
|
|
1425
|
+
callStack.expressions.push(...prefixes);
|
|
1426
|
+
for (let index = 0; index < operands.length; index++) {
|
|
1427
|
+
if (index >= 2 && !callStack.isFrozen) callStack.expressions.pop();
|
|
1428
|
+
const value = operands[index](context);
|
|
1429
|
+
if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
|
|
1430
|
+
if (value !== isAnd) {
|
|
1431
|
+
if (!callStack.isFrozen)
|
|
1432
|
+
callStack.expressions.length -= prefixes.length - Math.max(index - 1, 0);
|
|
1433
|
+
return value;
|
|
1434
|
+
}
|
|
1435
|
+
}
|
|
1436
|
+
return isAnd;
|
|
1437
|
+
};
|
|
1438
|
+
};
|
|
1439
|
+
|
|
1440
|
+
const traceFrames =
|
|
1441
|
+
(
|
|
1442
|
+
expression: Expression,
|
|
1443
|
+
frames: Expression[],
|
|
1444
|
+
evaluator: Evaluator,
|
|
1445
|
+
callStack: CallStack,
|
|
1446
|
+
): Evaluator =>
|
|
1447
|
+
(context) => {
|
|
1448
|
+
if (callStack.expressions.at(-1) === expression) return evaluator(context);
|
|
1449
|
+
callStack.expressions.push(...frames);
|
|
1450
|
+
try {
|
|
1451
|
+
return evaluator(context);
|
|
1452
|
+
} finally {
|
|
1453
|
+
if (!callStack.isFrozen) callStack.expressions.length -= frames.length;
|
|
1454
|
+
}
|
|
1455
|
+
};
|
|
1456
|
+
|
|
1457
|
+
const countEvaluator =
|
|
1458
|
+
(expression: Expression, evaluator: Evaluator, coverage: Coverage): Evaluator =>
|
|
1459
|
+
(context) => {
|
|
1460
|
+
const outer = coverage.current;
|
|
1461
|
+
if (outer === -1 || !coverage.covered.has(expression)) return evaluator(context);
|
|
1462
|
+
const node = getCoverageNode(coverage, outer, expression);
|
|
1463
|
+
countCoverage(coverage, node);
|
|
1464
|
+
coverage.current = node;
|
|
1465
|
+
try {
|
|
1466
|
+
const value = evaluator(context);
|
|
1467
|
+
const isTagged =
|
|
1468
|
+
expression.kind === "SetEnumeration" ||
|
|
1469
|
+
((expression.kind === "SetFilter" || expression.kind === "SetMap") &&
|
|
1470
|
+
isReducibleSet(value)) ||
|
|
1471
|
+
(expression.kind === "SetFilter" &&
|
|
1472
|
+
typeof value === "object" &&
|
|
1473
|
+
value.kind === "FilteredSet") ||
|
|
1474
|
+
((expression.kind === "FunctionSet" || expression.kind === "RecordSet") &&
|
|
1475
|
+
typeof value === "object" &&
|
|
1476
|
+
value.kind === expression.kind) ||
|
|
1477
|
+
(expression.kind === "Apply" &&
|
|
1478
|
+
expression.operator === "SUBSET" &&
|
|
1479
|
+
typeof value === "object" &&
|
|
1480
|
+
value.kind === "Subset");
|
|
1481
|
+
if (typeof value === "object" && isTagged) coverage.values.set(value, node);
|
|
1482
|
+
return value;
|
|
1483
|
+
} finally {
|
|
1484
|
+
coverage.current = outer;
|
|
1485
|
+
}
|
|
1486
|
+
};
|
|
1487
|
+
|
|
1248
1488
|
export const getEvaluator = (expression: Expression, environment: Environment): Evaluator => {
|
|
1249
1489
|
const cached = environment.evaluators.get(expression);
|
|
1250
1490
|
if (cached) return cached;
|
|
1251
1491
|
const compiled = compile(expression, environment);
|
|
1252
1492
|
const callStack = environment.callStack;
|
|
1253
|
-
const
|
|
1493
|
+
const frames = callStack && substitutionFrames.get(expression);
|
|
1494
|
+
const traced = callStack
|
|
1254
1495
|
? traceEvaluator(expression, compiled, environment, callStack)
|
|
1255
1496
|
: compiled;
|
|
1497
|
+
const framed = callStack && frames ? traceFrames(expression, frames, traced, callStack) : traced;
|
|
1498
|
+
const coverage = environment.coverage;
|
|
1499
|
+
const evaluator = coverage ? countEvaluator(expression, framed, coverage) : framed;
|
|
1256
1500
|
environment.evaluators.set(expression, evaluator);
|
|
1257
1501
|
return evaluator;
|
|
1258
1502
|
};
|
|
1259
1503
|
|
|
1260
1504
|
export const getEntryEvaluator = (expression: Expression, environment: Environment) => {
|
|
1261
|
-
if (environment.callStack) return getEvaluator(expression, environment);
|
|
1505
|
+
if (environment.callStack || environment.coverage) return getEvaluator(expression, environment);
|
|
1262
1506
|
const compiled = environment.entryEvaluators.get(expression);
|
|
1263
1507
|
if (compiled) return compiled;
|
|
1264
1508
|
const evaluator =
|
|
@@ -1289,12 +1533,9 @@ const compileIdentifier = (
|
|
|
1289
1533
|
return () => value;
|
|
1290
1534
|
}
|
|
1291
1535
|
if (global?.kind === "Definition") {
|
|
1292
|
-
// The body compiles when the reference is first evaluated, as a recursive definition's body
|
|
1293
|
-
// refers back to it.
|
|
1294
1536
|
const definition = global.definition;
|
|
1295
|
-
|
|
1296
|
-
return (context) =>
|
|
1297
|
-
(compiled.reference ??= getDefinitionEvaluator(definition, environment))(context);
|
|
1537
|
+
let compiled: Evaluator | undefined;
|
|
1538
|
+
return (context) => (compiled ??= getDefinitionEvaluator(definition, environment))(context);
|
|
1298
1539
|
}
|
|
1299
1540
|
return (context) => evaluateLocalIdentifier(name, expression, context);
|
|
1300
1541
|
};
|
|
@@ -1374,11 +1615,10 @@ const compileClosureCall = (
|
|
|
1374
1615
|
environment: Environment,
|
|
1375
1616
|
): Evaluator => {
|
|
1376
1617
|
const bindArguments = compileArgumentScope(closure, args, environment);
|
|
1377
|
-
|
|
1378
|
-
const compiled = { body: undefined as Evaluator | undefined };
|
|
1618
|
+
let body: Evaluator | undefined;
|
|
1379
1619
|
return (context) => {
|
|
1380
|
-
|
|
1381
|
-
return
|
|
1620
|
+
body ??= getEntryEvaluator(closure.body, environment);
|
|
1621
|
+
return body({
|
|
1382
1622
|
environment,
|
|
1383
1623
|
scope: bindArguments(context),
|
|
1384
1624
|
state: context.state,
|
|
@@ -1388,6 +1628,26 @@ const compileClosureCall = (
|
|
|
1388
1628
|
};
|
|
1389
1629
|
};
|
|
1390
1630
|
|
|
1631
|
+
// TLC's LET conses only its arity-0 definitions onto the context that TLCEval#tlcEval caches under when it is empty.
|
|
1632
|
+
const isTlcContextEmpty = (scope: Scope | undefined) => {
|
|
1633
|
+
for (let node = scope; node !== undefined; node = node.parent) {
|
|
1634
|
+
const binding = node.binding;
|
|
1635
|
+
if (
|
|
1636
|
+
binding.kind !== "Operator" ||
|
|
1637
|
+
binding.operator.kind !== "Closure" ||
|
|
1638
|
+
binding.operator.params.length === 0
|
|
1639
|
+
) {
|
|
1640
|
+
return false;
|
|
1641
|
+
}
|
|
1642
|
+
let letScope = binding.operator.scope;
|
|
1643
|
+
while (letScope !== undefined && letScope !== node) letScope = letScope.parent;
|
|
1644
|
+
if (letScope !== node) return false;
|
|
1645
|
+
}
|
|
1646
|
+
return true;
|
|
1647
|
+
};
|
|
1648
|
+
|
|
1649
|
+
const SET_OPERATORS = new Set(["\\cup", "\\cap", "\\"]);
|
|
1650
|
+
|
|
1391
1651
|
const compileApply = (
|
|
1392
1652
|
expression: Expression & { kind: "Apply" },
|
|
1393
1653
|
environment: Environment,
|
|
@@ -1397,12 +1657,24 @@ const compileApply = (
|
|
|
1397
1657
|
const left = getEvaluator(args[0], environment);
|
|
1398
1658
|
const right = getEvaluator(args[1], environment);
|
|
1399
1659
|
return (context) =>
|
|
1400
|
-
!
|
|
1401
|
-
|
|
1660
|
+
!expectImplication(left(context), expression, "P") ||
|
|
1661
|
+
expectImplication(right(context), expression, "Q");
|
|
1662
|
+
}
|
|
1663
|
+
if (expression.operator === "~" && args.length === 1) {
|
|
1664
|
+
const operand = getEvaluator(args[0], environment);
|
|
1665
|
+
return (context) => negate(operand(context), expression);
|
|
1402
1666
|
}
|
|
1403
|
-
if (expression.operator === "
|
|
1667
|
+
if (expression.operator === "<=>") {
|
|
1668
|
+
const left = getEvaluator(args[0], environment);
|
|
1669
|
+
const right = getEvaluator(args[1], environment);
|
|
1670
|
+
return (context) => isEquivalent(left(context), right(context), expression);
|
|
1671
|
+
}
|
|
1672
|
+
if (expression.operator === "~>" || expression.operator === "-+->") {
|
|
1404
1673
|
return () => {
|
|
1405
|
-
throw
|
|
1674
|
+
throw createTemporalFormulaError(
|
|
1675
|
+
expression.operator === "~>" ? "a ~> b" : "a -+-> formula",
|
|
1676
|
+
expression,
|
|
1677
|
+
);
|
|
1406
1678
|
};
|
|
1407
1679
|
}
|
|
1408
1680
|
const global = isLocallyResolved(expression)
|
|
@@ -1414,23 +1686,66 @@ const compileApply = (
|
|
|
1414
1686
|
const domain = getDomainOperator(expression);
|
|
1415
1687
|
return (context) => domain(operand(context));
|
|
1416
1688
|
}
|
|
1417
|
-
// TLC sorts the value of a constant TLCEval argument only where no context binds a name.
|
|
1418
1689
|
if (global?.kind === "Builtin" && global.name === "TLCEval" && args.length === 1) {
|
|
1419
|
-
|
|
1420
|
-
|
|
1421
|
-
|
|
1422
|
-
|
|
1423
|
-
return (context) =>
|
|
1424
|
-
|
|
1690
|
+
// Deviation from TLC: TLCEval#tlcEval evaluates an argument SANY takes for constant, such as Print(v, TRUE), in an empty state.
|
|
1691
|
+
const isCached =
|
|
1692
|
+
!contextualApplications.has(expression) && !isNonconstant(args[0], environment);
|
|
1693
|
+
const tlcEvalValues = environment.tlcEvalValues;
|
|
1694
|
+
return (context) => {
|
|
1695
|
+
if (!isCached || !isTlcContextEmpty(context.scope)) {
|
|
1696
|
+
return global.evaluate(getLazyArguments(args, context), context);
|
|
1697
|
+
}
|
|
1698
|
+
const cached = tlcEvalValues.get(expression);
|
|
1699
|
+
if (cached !== undefined) return cached;
|
|
1700
|
+
const value = global.evaluate(getLazyArguments(args, context), undefined);
|
|
1701
|
+
tlcEvalValues.set(expression, value);
|
|
1702
|
+
return value;
|
|
1703
|
+
};
|
|
1425
1704
|
}
|
|
1426
|
-
if (
|
|
1705
|
+
if (
|
|
1706
|
+
global?.kind === "Builtin" &&
|
|
1707
|
+
global.name === "\\subseteq" &&
|
|
1708
|
+
global.evaluateBinary &&
|
|
1709
|
+
args.length === 2
|
|
1710
|
+
) {
|
|
1427
1711
|
const left = getEvaluator(args[0], environment);
|
|
1428
1712
|
const right = getEvaluator(args[1], environment);
|
|
1429
|
-
const subset = getSubsetOperator(expression, global);
|
|
1430
|
-
|
|
1713
|
+
const subset = getSubsetOperator(expression, global.evaluateBinary);
|
|
1714
|
+
const coverage = environment.coverage;
|
|
1715
|
+
if (!coverage) return (context) => subset(left(context), right(context));
|
|
1716
|
+
return (context) => {
|
|
1717
|
+
const leftValue = left(context);
|
|
1718
|
+
const rightValue = right(context);
|
|
1719
|
+
if (
|
|
1720
|
+
typeof leftValue !== "object" ||
|
|
1721
|
+
leftValue.kind !== "Set" ||
|
|
1722
|
+
!coverage.values.has(leftValue)
|
|
1723
|
+
) {
|
|
1724
|
+
return subset(leftValue, rightValue);
|
|
1725
|
+
}
|
|
1726
|
+
const missing = leftValue.elements.findIndex((element) => !isElementOf(element, rightValue));
|
|
1727
|
+
costCoverage(coverage, leftValue, (missing === -1 ? leftValue.elements.length : missing) + 1);
|
|
1728
|
+
return missing === -1;
|
|
1729
|
+
};
|
|
1730
|
+
}
|
|
1731
|
+
const coverage = environment.coverage;
|
|
1732
|
+
const combine = global?.kind === "Builtin" ? global.evaluateBinary : undefined;
|
|
1733
|
+
if (coverage && combine && SET_OPERATORS.has(expression.operator) && args.length === 2) {
|
|
1734
|
+
const left = getEvaluator(args[0], environment);
|
|
1735
|
+
const right = getEvaluator(args[1], environment);
|
|
1736
|
+
return (context) => {
|
|
1737
|
+
const leftValue = left(context);
|
|
1738
|
+
const rightValue = right(context);
|
|
1739
|
+
return chargeSetOperation(
|
|
1740
|
+
coverage,
|
|
1741
|
+
expression.operator,
|
|
1742
|
+
leftValue,
|
|
1743
|
+
rightValue,
|
|
1744
|
+
combine(leftValue, rightValue),
|
|
1745
|
+
);
|
|
1746
|
+
};
|
|
1431
1747
|
}
|
|
1432
1748
|
if (global?.kind === "Builtin") return compileBuiltinCall(global, args, environment);
|
|
1433
|
-
// TLC refuses action composition unless a Java property enables its incomplete implementation.
|
|
1434
1749
|
if (expression.operator === "\\cdot" && args.length === 2) {
|
|
1435
1750
|
return () => {
|
|
1436
1751
|
throw new TlaEvaluationError(
|
|
@@ -1459,9 +1774,20 @@ const compileQuantifier = (
|
|
|
1459
1774
|
environment: Environment,
|
|
1460
1775
|
): Evaluator => {
|
|
1461
1776
|
const isForall = expression.kind === "Forall";
|
|
1462
|
-
const description = isForall ? "the body of \\A" : "the body of \\E";
|
|
1463
1777
|
const body = getEvaluator(expression.body, environment);
|
|
1464
1778
|
const bound = expression.bounds[0];
|
|
1779
|
+
const coverage = environment.coverage;
|
|
1780
|
+
if (coverage) {
|
|
1781
|
+
return (context) => {
|
|
1782
|
+
const isFound = forEachChargedBinding(
|
|
1783
|
+
expression.bounds,
|
|
1784
|
+
context,
|
|
1785
|
+
coverage,
|
|
1786
|
+
(scope) => expectBooleanBody(body(withScope(context, scope)), expression) !== isForall,
|
|
1787
|
+
);
|
|
1788
|
+
return isFound ? !isForall : isForall;
|
|
1789
|
+
};
|
|
1790
|
+
}
|
|
1465
1791
|
if (expression.bounds.length === 1 && bound.pattern.kind === "Name") {
|
|
1466
1792
|
const name = bound.pattern.name;
|
|
1467
1793
|
const set = getEvaluator(bound.set, environment);
|
|
@@ -1469,9 +1795,9 @@ const compileQuantifier = (
|
|
|
1469
1795
|
const isFound = someElement(
|
|
1470
1796
|
getQuantifierElements(set(context), bound.set, environment.runtime.version),
|
|
1471
1797
|
(element) =>
|
|
1472
|
-
|
|
1798
|
+
expectBooleanBody(
|
|
1473
1799
|
body(withScope(context, bindValue(context.scope, name, element))),
|
|
1474
|
-
|
|
1800
|
+
expression,
|
|
1475
1801
|
) !== isForall,
|
|
1476
1802
|
);
|
|
1477
1803
|
return isFound ? !isForall : isForall;
|
|
@@ -1480,14 +1806,17 @@ const compileQuantifier = (
|
|
|
1480
1806
|
const bounds = expression.bounds;
|
|
1481
1807
|
if (bounds.every((item) => item.pattern.kind === "Name")) {
|
|
1482
1808
|
const names = bounds.map((item) => (item.pattern.kind === "Name" ? item.pattern.name : ""));
|
|
1483
|
-
const sets = bounds.map((item) => getEvaluator(item.set, environment));
|
|
1484
1809
|
return (context) => {
|
|
1485
|
-
const lists =
|
|
1486
|
-
getQuantifierElements(
|
|
1810
|
+
const lists = mapBoundSets(bounds, (set) =>
|
|
1811
|
+
getQuantifierElements(
|
|
1812
|
+
getEvaluator(set, environment)(context),
|
|
1813
|
+
set,
|
|
1814
|
+
environment.runtime.version,
|
|
1815
|
+
),
|
|
1487
1816
|
);
|
|
1488
1817
|
const visit = (index: number, scope: Scope | undefined): boolean => {
|
|
1489
1818
|
if (index < 0) {
|
|
1490
|
-
return
|
|
1819
|
+
return expectBooleanBody(body(withScope(context, scope)), expression) !== isForall;
|
|
1491
1820
|
}
|
|
1492
1821
|
return someElement(lists[index], (element) =>
|
|
1493
1822
|
visit(index - 1, bindValue(scope, names[index], element)),
|
|
@@ -1500,7 +1829,7 @@ const compileQuantifier = (
|
|
|
1500
1829
|
const isFound = forEachBinding(
|
|
1501
1830
|
bounds,
|
|
1502
1831
|
context,
|
|
1503
|
-
(scope) =>
|
|
1832
|
+
(scope) => expectBooleanBody(body(withScope(context, scope)), expression) !== isForall,
|
|
1504
1833
|
);
|
|
1505
1834
|
return isFound ? !isForall : isForall;
|
|
1506
1835
|
};
|
|
@@ -1519,8 +1848,6 @@ const getBoundValue = (pattern: BoundPattern, scope: Scope | undefined) => {
|
|
|
1519
1848
|
return binding?.kind === "Value" ? binding.value : undefined;
|
|
1520
1849
|
};
|
|
1521
1850
|
|
|
1522
|
-
// TLC keeps a function constructor lazy when it is the function of an application, or the base of
|
|
1523
|
-
// an EXCEPT that is, so it evaluates the body only at the arguments it is applied to.
|
|
1524
1851
|
const keptLazyExpressions = new WeakSet<Expression>();
|
|
1525
1852
|
|
|
1526
1853
|
export const keepLazy = (expression: Expression) => {
|
|
@@ -1529,32 +1856,69 @@ export const keepLazy = (expression: Expression) => {
|
|
|
1529
1856
|
}
|
|
1530
1857
|
};
|
|
1531
1858
|
|
|
1532
|
-
const
|
|
1859
|
+
const scopeNames = new WeakMap<Expression, string[] | undefined>();
|
|
1860
|
+
|
|
1861
|
+
const getScopeNames = (expression: Expression) => {
|
|
1862
|
+
if (scopeNames.has(expression)) return scopeNames.get(expression);
|
|
1863
|
+
const names = new Set<string>();
|
|
1864
|
+
const visit = (node: Expression): boolean => {
|
|
1865
|
+
if (node.kind === "Subexpression") return false;
|
|
1866
|
+
const name = getReferencedName(node);
|
|
1867
|
+
if (name !== undefined) names.add(name);
|
|
1868
|
+
if (node.kind === "ExceptAt") names.add(EXCEPT_AT);
|
|
1869
|
+
return getChildren(node).every(visit);
|
|
1870
|
+
};
|
|
1871
|
+
const result = visit(expression) ? [...names] : undefined;
|
|
1872
|
+
scopeNames.set(expression, result);
|
|
1873
|
+
return result;
|
|
1874
|
+
};
|
|
1875
|
+
|
|
1876
|
+
const trimScope = (scope: Scope | undefined, names: string[] | undefined) =>
|
|
1877
|
+
names === undefined || scope === undefined
|
|
1878
|
+
? scope
|
|
1879
|
+
: names.reduce<Scope>(
|
|
1880
|
+
(trimmed, name) => {
|
|
1881
|
+
const binding = lookupScope(scope, name);
|
|
1882
|
+
return binding ? { name, binding, parent: trimmed } : trimmed;
|
|
1883
|
+
},
|
|
1884
|
+
{ name: "", binding: { kind: "Value", value: false }, parent: undefined },
|
|
1885
|
+
);
|
|
1886
|
+
|
|
1887
|
+
export const isKeptLazy = (expression: Expression) => keptLazyExpressions.has(expression);
|
|
1888
|
+
|
|
1889
|
+
export const getFunctionBuilder = (
|
|
1533
1890
|
expression: Expression & { kind: "FunctionConstruction" },
|
|
1534
1891
|
environment: Environment,
|
|
1535
|
-
)
|
|
1536
|
-
const
|
|
1892
|
+
) => {
|
|
1893
|
+
const isKeptLazyExpression = isKeptLazy(expression);
|
|
1537
1894
|
const body = getEvaluator(expression.body, environment);
|
|
1538
1895
|
const bounds = expression.bounds;
|
|
1539
1896
|
const bound = bounds[0];
|
|
1540
1897
|
const isSingleName = bounds.length === 1 && bound.pattern.kind === "Name";
|
|
1541
|
-
const set = getEvaluator(bound.set, environment);
|
|
1542
1898
|
const construct = (domain: Value, context: Context) => {
|
|
1543
1899
|
if (isSingleName && bound.pattern.kind === "Name") {
|
|
1544
1900
|
const name = bound.pattern.name;
|
|
1901
|
+
const evaluateAt = (key: Value) =>
|
|
1902
|
+
body(withScope(context, bindValue(context.scope, name, key)));
|
|
1903
|
+
// TLC sizes the domain and evaluates the body at each element of a domain too large to hold.
|
|
1904
|
+
if (isBeyondSetBound(domain)) {
|
|
1905
|
+
getCardinality(domain);
|
|
1906
|
+
forEachElement(domain, evaluateAt);
|
|
1907
|
+
return createLazy(domain, context);
|
|
1908
|
+
}
|
|
1545
1909
|
const keys = getFunctionDomain(domain);
|
|
1546
|
-
const functionValue = createSortedFunction(
|
|
1547
|
-
|
|
1548
|
-
|
|
1549
|
-
);
|
|
1550
|
-
// FcnLambdaValue#toFcnRcd builds a FcnRcdValue over an interval or an enumerated set.
|
|
1551
|
-
return isReducibleSet(domain) ? functionValue : markLambdaFunction(functionValue);
|
|
1910
|
+
const functionValue = createSortedFunction(keys, keys.map(evaluateAt));
|
|
1911
|
+
if (isReducibleSet(domain)) return functionValue;
|
|
1912
|
+
functionValue.lambdaDomain = domain;
|
|
1913
|
+
return markLambdaFunction(functionValue);
|
|
1552
1914
|
}
|
|
1553
1915
|
const pairs: [Value, Value][] = [];
|
|
1554
|
-
const sets = bounds
|
|
1916
|
+
const sets = mapBoundSets(bounds, (set, index) =>
|
|
1555
1917
|
getNormalizedElements(
|
|
1556
|
-
|
|
1557
|
-
|
|
1918
|
+
bounds.length > 1 && typeof domain === "object" && domain.kind === "ProductSet"
|
|
1919
|
+
? domain.factors[index]
|
|
1920
|
+
: domain,
|
|
1921
|
+
set,
|
|
1558
1922
|
context.environment.runtime.version,
|
|
1559
1923
|
),
|
|
1560
1924
|
);
|
|
@@ -1569,13 +1933,26 @@ const compileFunctionConstruction = (
|
|
|
1569
1933
|
return createFunction(pairs);
|
|
1570
1934
|
};
|
|
1571
1935
|
const template = getLazyFunctionTemplate(bounds, expression.body);
|
|
1936
|
+
const boundTupleLengths = getBoundTupleLengths(bounds);
|
|
1937
|
+
const bodyNames = getScopeNames(expression.body);
|
|
1938
|
+
const coverage = environment.coverage;
|
|
1572
1939
|
const createLazy = (domain: Value, context: Context) => {
|
|
1573
|
-
const scope = context.scope;
|
|
1940
|
+
const scope = trimScope(context.scope, bodyNames);
|
|
1941
|
+
const lambdaContext = withScope(context, scope);
|
|
1942
|
+
const compute = (argument: Value) =>
|
|
1943
|
+
body(withScope(lambdaContext, bindArgument(bounds, scope, argument)));
|
|
1944
|
+
const node = coverage && !environment.callStack ? coverage.current : -1;
|
|
1574
1945
|
const functionValue = keepLambda({
|
|
1575
1946
|
value: createLazyFunction(
|
|
1576
1947
|
domain,
|
|
1577
|
-
|
|
1948
|
+
coverage
|
|
1949
|
+
? (argument) =>
|
|
1950
|
+
coverage.current === -1
|
|
1951
|
+
? compute(argument)
|
|
1952
|
+
: runAtCoverageNode(coverage, node, () => compute(argument))
|
|
1953
|
+
: compute,
|
|
1578
1954
|
getLazyFunctionSource(template, bounds, domain),
|
|
1955
|
+
boundTupleLengths,
|
|
1579
1956
|
),
|
|
1580
1957
|
bounds,
|
|
1581
1958
|
body: expression.body,
|
|
@@ -1584,15 +1961,22 @@ const compileFunctionConstruction = (
|
|
|
1584
1961
|
return bounds.length === 1 ? markLambdaFunction(functionValue) : functionValue;
|
|
1585
1962
|
};
|
|
1586
1963
|
const callStack = environment.callStack;
|
|
1587
|
-
|
|
1588
|
-
|
|
1589
|
-
|
|
1964
|
+
const build = (domain: Value, context: Context) => {
|
|
1965
|
+
if (
|
|
1966
|
+
expression.isRecursive ||
|
|
1967
|
+
isKeptLazyExpression ||
|
|
1968
|
+
context.isKeepLazy ||
|
|
1969
|
+
!isEnumerable(domain)
|
|
1970
|
+
) {
|
|
1590
1971
|
return createLazy(domain, context);
|
|
1591
1972
|
}
|
|
1592
|
-
|
|
1593
|
-
|
|
1594
|
-
|
|
1595
|
-
|
|
1973
|
+
const isReducibleDomain =
|
|
1974
|
+
bounds.length === 1
|
|
1975
|
+
? isReducibleSet(domain)
|
|
1976
|
+
: typeof domain === "object" &&
|
|
1977
|
+
domain.kind === "ProductSet" &&
|
|
1978
|
+
domain.factors.every(isReducibleSet);
|
|
1979
|
+
if (!isReducibleDomain) {
|
|
1596
1980
|
if (callStack) return createLazy(domain, context);
|
|
1597
1981
|
try {
|
|
1598
1982
|
return construct(domain, context);
|
|
@@ -1602,7 +1986,6 @@ const compileFunctionConstruction = (
|
|
|
1602
1986
|
}
|
|
1603
1987
|
}
|
|
1604
1988
|
if (!callStack) return construct(domain, context);
|
|
1605
|
-
// TLC builds the function in a method of the FcnLambdaValue that CallStackTool gives a source.
|
|
1606
1989
|
try {
|
|
1607
1990
|
return construct(domain, context);
|
|
1608
1991
|
} catch (error) {
|
|
@@ -1610,14 +1993,45 @@ const compileFunctionConstruction = (
|
|
|
1610
1993
|
throw error;
|
|
1611
1994
|
}
|
|
1612
1995
|
};
|
|
1996
|
+
return { build, createLazy };
|
|
1997
|
+
};
|
|
1998
|
+
|
|
1999
|
+
const compileFunctionConstruction = (
|
|
2000
|
+
expression: Expression & { kind: "FunctionConstruction" },
|
|
2001
|
+
environment: Environment,
|
|
2002
|
+
): Evaluator => {
|
|
2003
|
+
const build = getFunctionBuilder(expression, environment).build;
|
|
2004
|
+
const bounds = expression.bounds;
|
|
2005
|
+
const coverage = environment.coverage;
|
|
2006
|
+
if (coverage) {
|
|
2007
|
+
return (context) => {
|
|
2008
|
+
const domain = getBoundsDomain(bounds, context);
|
|
2009
|
+
const value = build(domain, context);
|
|
2010
|
+
const sets =
|
|
2011
|
+
bounds.length === 1 || typeof domain !== "object" || domain.kind !== "ProductSet"
|
|
2012
|
+
? [domain]
|
|
2013
|
+
: domain.factors;
|
|
2014
|
+
const isConverted =
|
|
2015
|
+
(typeof value !== "object" || value.kind !== "LazyFunction") && sets.every(isReducibleSet);
|
|
2016
|
+
if (isConverted && coverage.current !== -1 && coverage.covered.has(expression)) {
|
|
2017
|
+
chargeFunctionConstruction(coverage, coverage.current, sets);
|
|
2018
|
+
}
|
|
2019
|
+
return value;
|
|
2020
|
+
};
|
|
2021
|
+
}
|
|
2022
|
+
if (bounds.length === 1 && bounds[0].pattern.kind === "Name") {
|
|
2023
|
+
const set = getEvaluator(bounds[0].set, environment);
|
|
2024
|
+
return (context) => build(set(context), context);
|
|
2025
|
+
}
|
|
2026
|
+
return (context) => build(getBoundsDomain(bounds, context), context);
|
|
1613
2027
|
};
|
|
1614
2028
|
|
|
1615
2029
|
const compileExcept = (
|
|
1616
2030
|
expression: Expression & { kind: "Except" },
|
|
1617
2031
|
environment: Environment,
|
|
1618
2032
|
): Evaluator => {
|
|
1619
|
-
const
|
|
1620
|
-
if (
|
|
2033
|
+
const isKeptLazyExpression = keptLazyExpressions.has(expression);
|
|
2034
|
+
if (isKeptLazyExpression) keepLazy(expression.function);
|
|
1621
2035
|
const evaluateFunction = getEvaluator(expression.function, environment);
|
|
1622
2036
|
const updates = expression.updates.map((update) => ({
|
|
1623
2037
|
path: update.path.map((step): CompiledStep =>
|
|
@@ -1650,19 +2064,18 @@ const compileExcept = (
|
|
|
1650
2064
|
current,
|
|
1651
2065
|
getKey(path[depth], context),
|
|
1652
2066
|
(previous) => update(previous, path, depth + 1, context, value),
|
|
1653
|
-
|
|
2067
|
+
isKeptLazyExpression && depth === 0,
|
|
1654
2068
|
);
|
|
1655
2069
|
};
|
|
1656
2070
|
return (context) => {
|
|
1657
2071
|
let current = evaluateFunction(context);
|
|
1658
2072
|
for (const item of updates) {
|
|
1659
|
-
|
|
1660
|
-
const found = { value: false };
|
|
2073
|
+
let isFound = false;
|
|
1661
2074
|
current = update(current, item.path, 0, context, (inner) => {
|
|
1662
|
-
|
|
2075
|
+
isFound = true;
|
|
1663
2076
|
return item.value(inner);
|
|
1664
2077
|
});
|
|
1665
|
-
if (!
|
|
2078
|
+
if (!isFound) {
|
|
1666
2079
|
context.environment.runtime.warn(
|
|
1667
2080
|
MESSAGE_CODE.exceptAppliedToUnknownField,
|
|
1668
2081
|
`The EXCEPT was applied to non-existing fields of the value at\n${describeRange(expression.function)}`,
|
|
@@ -1673,6 +2086,119 @@ const compileExcept = (
|
|
|
1673
2086
|
};
|
|
1674
2087
|
};
|
|
1675
2088
|
|
|
2089
|
+
export const getLazyFilter = (
|
|
2090
|
+
expression: Expression & { kind: "SetFilter" },
|
|
2091
|
+
environment: Environment,
|
|
2092
|
+
) => {
|
|
2093
|
+
const predicate = getEvaluator(expression.predicate, environment);
|
|
2094
|
+
const pattern = expression.bound.pattern;
|
|
2095
|
+
const predicateNode = describeNode(expression.predicate);
|
|
2096
|
+
const source = expression.predicate.location.range && {
|
|
2097
|
+
names: pattern.kind === "Name" ? pattern.name : pattern.names.join(", "),
|
|
2098
|
+
predicate: predicateNode,
|
|
2099
|
+
};
|
|
2100
|
+
const coverage = environment.coverage;
|
|
2101
|
+
const createFiltered = (
|
|
2102
|
+
base: Value,
|
|
2103
|
+
context: Context,
|
|
2104
|
+
evaluator: Evaluator,
|
|
2105
|
+
node: number,
|
|
2106
|
+
): RebindableFilteredSet => {
|
|
2107
|
+
const test = (element: Value, isMember: boolean) => {
|
|
2108
|
+
if (
|
|
2109
|
+
pattern.kind === "Tuple" &&
|
|
2110
|
+
getSequenceElements(element)?.length !== pattern.names.length
|
|
2111
|
+
) {
|
|
2112
|
+
throw new TlaEvaluationError(
|
|
2113
|
+
`Attempted to check if the value:\n${prettyPrint(formatValue(element))}\nis an element of a set of ${pattern.names.length}-tuples.`,
|
|
2114
|
+
);
|
|
2115
|
+
}
|
|
2116
|
+
const value = evaluator(withScope(context, bindPattern(context.scope, pattern, element)));
|
|
2117
|
+
if (typeof value !== "boolean") {
|
|
2118
|
+
throw new TlaEvaluationError(
|
|
2119
|
+
`${isMember ? "The evaluation of predicate" : "Evaluating predicate"} ${predicateNode} yielded non-Boolean value.`,
|
|
2120
|
+
);
|
|
2121
|
+
}
|
|
2122
|
+
return value;
|
|
2123
|
+
};
|
|
2124
|
+
const rebind = (tracing: Environment) =>
|
|
2125
|
+
createFiltered(
|
|
2126
|
+
base,
|
|
2127
|
+
{ ...context, environment: tracing },
|
|
2128
|
+
getEvaluator(expression.predicate, tracing),
|
|
2129
|
+
-1,
|
|
2130
|
+
);
|
|
2131
|
+
if (!coverage || node === -1) return { kind: "FilteredSet", base, test, source, rebind };
|
|
2132
|
+
return {
|
|
2133
|
+
kind: "FilteredSet",
|
|
2134
|
+
base,
|
|
2135
|
+
test: (element, isMember) =>
|
|
2136
|
+
runAtCoverageNode(coverage, isMember ? -1 : node, () => test(element, isMember)),
|
|
2137
|
+
startPass: (isMaterialized) => {
|
|
2138
|
+
const draws = createProductSetEnumerator(coverage, base);
|
|
2139
|
+
return (element) => {
|
|
2140
|
+
draws?.next();
|
|
2141
|
+
tagSubset(coverage, base, element);
|
|
2142
|
+
coverage.secondary[node]++;
|
|
2143
|
+
const value = runAtCoverageNode(coverage, node, () => test(element, false));
|
|
2144
|
+
if (isMaterialized && value) coverage.secondary[node]++;
|
|
2145
|
+
return value;
|
|
2146
|
+
};
|
|
2147
|
+
},
|
|
2148
|
+
source,
|
|
2149
|
+
rebind,
|
|
2150
|
+
};
|
|
2151
|
+
};
|
|
2152
|
+
return (base: Value, context: Context, node = -1) =>
|
|
2153
|
+
createFiltered(base, context, predicate, node);
|
|
2154
|
+
};
|
|
2155
|
+
|
|
2156
|
+
const hasLocalName = (expression: Expression): boolean =>
|
|
2157
|
+
isLocallyResolved(expression) ||
|
|
2158
|
+
expression.kind === "OperatorReference" ||
|
|
2159
|
+
getChildren(expression).some(hasLocalName);
|
|
2160
|
+
|
|
2161
|
+
export const isUniformPredicate = (
|
|
2162
|
+
expression: Expression & { kind: "SetFilter" },
|
|
2163
|
+
environment: Environment,
|
|
2164
|
+
) =>
|
|
2165
|
+
expression.bound.pattern.kind === "Name" &&
|
|
2166
|
+
!environment.coverage &&
|
|
2167
|
+
!hasLocalName(expression.predicate) &&
|
|
2168
|
+
!isExpressionImpure([expression.predicate], environment, "varying");
|
|
2169
|
+
|
|
2170
|
+
export const expectFilterPredicate = (
|
|
2171
|
+
value: Value,
|
|
2172
|
+
expression: Expression & { kind: "SetFilter" },
|
|
2173
|
+
) => {
|
|
2174
|
+
if (typeof value !== "boolean") {
|
|
2175
|
+
throw new TlaEvaluationError(
|
|
2176
|
+
`Attempted to evaluate an expression of form {x \\in S : P(x)} when P was ${getKindString(value)}.\n${describeNode(expression.predicate)}`,
|
|
2177
|
+
);
|
|
2178
|
+
}
|
|
2179
|
+
return value;
|
|
2180
|
+
};
|
|
2181
|
+
|
|
2182
|
+
export const getChoiceElements = (
|
|
2183
|
+
base: Value,
|
|
2184
|
+
expression: Expression & { kind: "Choose" },
|
|
2185
|
+
set: Expression,
|
|
2186
|
+
version: TlcVersion,
|
|
2187
|
+
) => {
|
|
2188
|
+
if (!isSetValue(base) || isOverriddenSet(base)) {
|
|
2189
|
+
throw new TlaEvaluationError(
|
|
2190
|
+
`Attempted to compute the value of an expression of\nform CHOOSE x \\in S: P, but S was not enumerable.\n${describeRange(expression)}`,
|
|
2191
|
+
);
|
|
2192
|
+
}
|
|
2193
|
+
normalizeShallowly(base);
|
|
2194
|
+
return getNormalizedElements(base, set, version);
|
|
2195
|
+
};
|
|
2196
|
+
|
|
2197
|
+
export const createNoChoiceError = (expression: Expression & { kind: "Choose" }) =>
|
|
2198
|
+
new TlaEvaluationError(
|
|
2199
|
+
`Attempted to compute the value of an expression of form\nCHOOSE x \\in S: P, but no element of S satisfied P.\n${describeRange(expression)}`,
|
|
2200
|
+
);
|
|
2201
|
+
|
|
1676
2202
|
const compileSetComprehension = (
|
|
1677
2203
|
expression: Expression & { kind: "SetFilter" | "SetMap" | "Choose" },
|
|
1678
2204
|
environment: Environment,
|
|
@@ -1680,48 +2206,37 @@ const compileSetComprehension = (
|
|
|
1680
2206
|
if (expression.kind === "SetFilter") {
|
|
1681
2207
|
const predicate = getEvaluator(expression.predicate, environment);
|
|
1682
2208
|
const set = getEvaluator(expression.bound.set, environment);
|
|
2209
|
+
const filterLazily = getLazyFilter(expression, environment);
|
|
1683
2210
|
const pattern = expression.bound.pattern;
|
|
1684
|
-
const
|
|
1685
|
-
const
|
|
1686
|
-
names: pattern.kind === "Name" ? pattern.name : pattern.names.join(", "),
|
|
1687
|
-
predicate: formatRange(range),
|
|
1688
|
-
};
|
|
1689
|
-
const createTest = (evaluator: Evaluator, context: Context) => (element: Value) =>
|
|
1690
|
-
expectBoolean(
|
|
1691
|
-
evaluator(withScope(context, bindPattern(context.scope, pattern, element))),
|
|
1692
|
-
"a set filter predicate",
|
|
1693
|
-
);
|
|
1694
|
-
const createFiltered = (
|
|
1695
|
-
base: Value,
|
|
1696
|
-
context: Context,
|
|
1697
|
-
evaluator: Evaluator,
|
|
1698
|
-
): RebindableFilteredSet => ({
|
|
1699
|
-
kind: "FilteredSet",
|
|
1700
|
-
base,
|
|
1701
|
-
test: createTest(evaluator, context),
|
|
1702
|
-
source,
|
|
1703
|
-
rebind: (tracing) =>
|
|
1704
|
-
createFiltered(
|
|
1705
|
-
base,
|
|
1706
|
-
{ ...context, environment: tracing },
|
|
1707
|
-
getEvaluator(expression.predicate, tracing),
|
|
1708
|
-
),
|
|
1709
|
-
});
|
|
2211
|
+
const coverage = environment.coverage;
|
|
2212
|
+
const isUniform = isUniformPredicate(expression, environment);
|
|
1710
2213
|
return (context) => {
|
|
1711
2214
|
const base = set(context);
|
|
1712
|
-
|
|
1713
|
-
|
|
1714
|
-
|
|
2215
|
+
if (!isReducibleSet(base)) return filterLazily(base, context, coverage?.current);
|
|
2216
|
+
const kept: Value[] = [];
|
|
2217
|
+
const elements = base.kind === "Interval" ? base : toFiniteSet(base).elements;
|
|
2218
|
+
const size = Array.isArray(elements) ? elements.length : elements.high - elements.low + 1;
|
|
2219
|
+
for (let position = 0; position < size; position++) {
|
|
2220
|
+
const element = Array.isArray(elements) ? elements[position] : elements.low + position;
|
|
2221
|
+
const value = predicate(withScope(context, bindPattern(context.scope, pattern, element)));
|
|
2222
|
+
if (expectFilterPredicate(value, expression)) addBoundedElement(kept, element);
|
|
2223
|
+
else if (isUniform) break;
|
|
2224
|
+
}
|
|
2225
|
+
if (coverage) costCoverage(coverage, base, size + 1);
|
|
2226
|
+
return createNormalizedSet(kept);
|
|
1715
2227
|
};
|
|
1716
2228
|
}
|
|
1717
2229
|
if (expression.kind === "SetMap") {
|
|
1718
2230
|
const mapped = getEvaluator(expression.expression, environment);
|
|
2231
|
+
const coverage = environment.coverage;
|
|
1719
2232
|
return (context) => {
|
|
1720
2233
|
const elements: Value[] = [];
|
|
1721
|
-
|
|
1722
|
-
elements
|
|
2234
|
+
const add = (scope: Scope | undefined) => {
|
|
2235
|
+
addBoundedElement(elements, mapped(withScope(context, scope)));
|
|
1723
2236
|
return false;
|
|
1724
|
-
}
|
|
2237
|
+
};
|
|
2238
|
+
if (coverage) forEachChargedBinding(expression.bounds, context, coverage, add);
|
|
2239
|
+
else forEachBinding(expression.bounds, context, add);
|
|
1725
2240
|
return createEnumeratedSet(elements);
|
|
1726
2241
|
};
|
|
1727
2242
|
}
|
|
@@ -1729,37 +2244,40 @@ const compileSetComprehension = (
|
|
|
1729
2244
|
if (!set) {
|
|
1730
2245
|
return () => {
|
|
1731
2246
|
throw new TlaEvaluationError(
|
|
1732
|
-
`TLC
|
|
2247
|
+
`TLC attempted to evaluate an unbounded CHOOSE.\nMake sure that the expression is of form CHOOSE x \\in S: P(x).\n${describeRange(expression)}`,
|
|
1733
2248
|
);
|
|
1734
2249
|
};
|
|
1735
2250
|
}
|
|
1736
2251
|
const body = getEvaluator(expression.body, environment);
|
|
1737
2252
|
const evaluateSet = getEvaluator(set, environment);
|
|
2253
|
+
const coverage = environment.coverage;
|
|
1738
2254
|
return (context) => {
|
|
1739
2255
|
const base = evaluateSet(context);
|
|
1740
|
-
|
|
1741
|
-
|
|
1742
|
-
|
|
1743
|
-
|
|
1744
|
-
}
|
|
1745
|
-
const chosen = { value: undefined as Value | undefined };
|
|
1746
|
-
const elements = getNormalizedElements(base, set, context.environment.runtime.version);
|
|
2256
|
+
const elements = getChoiceElements(base, expression, set, context.environment.runtime.version);
|
|
2257
|
+
const enumerator = coverage && createChargedEnumerator(coverage, base, elements, true);
|
|
2258
|
+
let chosen: Value | undefined;
|
|
2259
|
+
const pattern = expression.pattern;
|
|
1747
2260
|
someElement(elements, (element) => {
|
|
1748
|
-
|
|
1749
|
-
if (
|
|
1750
|
-
|
|
2261
|
+
enumerator?.next();
|
|
2262
|
+
if (
|
|
2263
|
+
pattern.kind === "Tuple" &&
|
|
2264
|
+
getSequenceElements(element)?.length !== pattern.names.length
|
|
2265
|
+
) {
|
|
2266
|
+
throw new TlaEvaluationError(
|
|
2267
|
+
`Attempted to compute the value of an expression of form\nCHOOSE <<x1, ... , xN>> \\in S: P, but S was not a set\nof N-tuples.\n${describeRange(expression)}`,
|
|
2268
|
+
);
|
|
2269
|
+
}
|
|
2270
|
+
const scope = bindPattern(context.scope, pattern, element);
|
|
2271
|
+
if (!expectBooleanBody(body(withScope(context, scope)), expression)) return false;
|
|
2272
|
+
chosen = getBoundValue(pattern, scope);
|
|
1751
2273
|
return true;
|
|
1752
2274
|
});
|
|
1753
|
-
if (chosen
|
|
1754
|
-
|
|
1755
|
-
|
|
1756
|
-
);
|
|
1757
|
-
}
|
|
1758
|
-
return chosen.value;
|
|
2275
|
+
if (chosen !== undefined) return chosen;
|
|
2276
|
+
enumerator?.next();
|
|
2277
|
+
throw createNoChoiceError(expression);
|
|
1759
2278
|
};
|
|
1760
2279
|
};
|
|
1761
2280
|
|
|
1762
|
-
// TLC orders a record's fields by name.
|
|
1763
2281
|
export const getSortedFields = (fields: RecordField[]) =>
|
|
1764
2282
|
[...fields].sort((left, right) => compareValues(left.name, right.name));
|
|
1765
2283
|
|
|
@@ -1768,20 +2286,21 @@ export const hasDuplicateFields = (sortedFields: RecordField[]) =>
|
|
|
1768
2286
|
|
|
1769
2287
|
const compileRecord = (recordFields: RecordField[], environment: Environment): Evaluator => {
|
|
1770
2288
|
const fields = getSortedFields(recordFields);
|
|
1771
|
-
const
|
|
1772
|
-
|
|
1773
|
-
if (hasDuplicates) {
|
|
2289
|
+
const values = recordFields.map((field) => getEvaluator(field.value, environment));
|
|
2290
|
+
if (hasDuplicateFields(fields)) {
|
|
1774
2291
|
return (context) =>
|
|
1775
2292
|
createRecord(
|
|
1776
|
-
|
|
2293
|
+
recordFields.map((field, index): [string, Value] => [field.name, values[index](context)]),
|
|
1777
2294
|
);
|
|
1778
2295
|
}
|
|
1779
2296
|
const names = fields.map((field) => field.name);
|
|
1780
2297
|
const writtenNames = recordFields.map((field) => field.name);
|
|
1781
2298
|
if (writtenNames.some((name, index) => name !== names[index])) {
|
|
2299
|
+
const writtenIndexes = fields.map((field) => recordFields.indexOf(field));
|
|
1782
2300
|
return (context) =>
|
|
1783
2301
|
createWrittenRecord(
|
|
1784
2302
|
names,
|
|
2303
|
+
writtenIndexes,
|
|
1785
2304
|
values.map((value) => value(context)),
|
|
1786
2305
|
writtenNames,
|
|
1787
2306
|
);
|
|
@@ -1831,48 +2350,38 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
1831
2350
|
};
|
|
1832
2351
|
case "And": {
|
|
1833
2352
|
const operands = expression.operands.map(getChildEvaluator);
|
|
1834
|
-
return (
|
|
1835
|
-
|
|
1836
|
-
|
|
1837
|
-
|
|
1838
|
-
|
|
1839
|
-
|
|
1840
|
-
|
|
1841
|
-
|
|
2353
|
+
return (
|
|
2354
|
+
compileTracedJunction(expression, operands, environment.callStack) ??
|
|
2355
|
+
((context) => {
|
|
2356
|
+
for (let index = 0; index < operands.length; index++) {
|
|
2357
|
+
const value = operands[index](context);
|
|
2358
|
+
if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
|
|
2359
|
+
if (!value) return false;
|
|
2360
|
+
}
|
|
2361
|
+
return true;
|
|
2362
|
+
})
|
|
2363
|
+
);
|
|
1842
2364
|
}
|
|
1843
2365
|
case "Or": {
|
|
1844
2366
|
const operands = expression.operands.map(getChildEvaluator);
|
|
1845
|
-
return (
|
|
1846
|
-
|
|
1847
|
-
|
|
1848
|
-
|
|
1849
|
-
|
|
1850
|
-
|
|
1851
|
-
|
|
1852
|
-
|
|
2367
|
+
return (
|
|
2368
|
+
compileTracedJunction(expression, operands, environment.callStack) ??
|
|
2369
|
+
((context) => {
|
|
2370
|
+
for (let index = 0; index < operands.length; index++) {
|
|
2371
|
+
const value = operands[index](context);
|
|
2372
|
+
if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
|
|
2373
|
+
if (value) return true;
|
|
2374
|
+
}
|
|
2375
|
+
return false;
|
|
2376
|
+
})
|
|
2377
|
+
);
|
|
1853
2378
|
}
|
|
1854
2379
|
case "Prime": {
|
|
1855
2380
|
const inner = getChildEvaluator(expression.expression);
|
|
1856
|
-
return (context) =>
|
|
1857
|
-
if (!context.next) throw createPrimeOutsideActionError(expression);
|
|
1858
|
-
return inner({
|
|
1859
|
-
environment: context.environment,
|
|
1860
|
-
scope: context.scope,
|
|
1861
|
-
state: context.next,
|
|
1862
|
-
next: undefined,
|
|
1863
|
-
isKeepLazy: context.isKeepLazy,
|
|
1864
|
-
});
|
|
1865
|
-
};
|
|
1866
|
-
}
|
|
1867
|
-
case "Unchanged": {
|
|
1868
|
-
const primed = getChildEvaluator({
|
|
1869
|
-
kind: "Prime",
|
|
1870
|
-
expression: expression.expression,
|
|
1871
|
-
location: expression.location,
|
|
1872
|
-
});
|
|
1873
|
-
const current = getChildEvaluator(expression.expression);
|
|
1874
|
-
return (context) => valuesEqual(primed(context), current(context));
|
|
2381
|
+
return (context) => inner(toNextContext(context));
|
|
1875
2382
|
}
|
|
2383
|
+
case "Unchanged":
|
|
2384
|
+
return compileUnchanged(getChildEvaluator(expression.expression));
|
|
1876
2385
|
case "If": {
|
|
1877
2386
|
const condition = getChildEvaluator(expression.condition);
|
|
1878
2387
|
const consequent = getChildEvaluator(expression.consequent);
|
|
@@ -1916,8 +2425,15 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
1916
2425
|
return compileQuantifier(expression, environment);
|
|
1917
2426
|
case "UnboundedQuantifier":
|
|
1918
2427
|
return () => {
|
|
2428
|
+
const operator = expression.quantifier === "Forall" ? "\\A" : "\\E";
|
|
2429
|
+
if (expression.isTemporal) {
|
|
2430
|
+
throw createTemporalFormulaError(
|
|
2431
|
+
expression.quantifier === "Forall" ? "\\AA" : "\\EE",
|
|
2432
|
+
expression,
|
|
2433
|
+
);
|
|
2434
|
+
}
|
|
1919
2435
|
throw new TlaEvaluationError(
|
|
1920
|
-
`TLC
|
|
2436
|
+
`TLC attempted to evaluate an unbounded ${operator}.\nMake sure that the expression is of form ${operator} x \\in S: P(x).\n${describeRange(expression)}`,
|
|
1921
2437
|
);
|
|
1922
2438
|
};
|
|
1923
2439
|
case "Choose":
|
|
@@ -1944,8 +2460,19 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
1944
2460
|
case "RecordSet": {
|
|
1945
2461
|
const fields = getSortedFields(expression.fields);
|
|
1946
2462
|
const names = fields.map((field) => field.name);
|
|
1947
|
-
const
|
|
1948
|
-
|
|
2463
|
+
const writtenIndexes = fields.map((field) => expression.fields.indexOf(field));
|
|
2464
|
+
const sets = expression.fields.map((field) => getChildEvaluator(field.value));
|
|
2465
|
+
if (writtenIndexes.every((writtenIndex, index) => writtenIndex === index)) {
|
|
2466
|
+
return (context) => ({ kind: "RecordSet", names, sets: sets.map((set) => set(context)) });
|
|
2467
|
+
}
|
|
2468
|
+
return (context) => {
|
|
2469
|
+
const writtenSets = sets.map((set) => set(context));
|
|
2470
|
+
return {
|
|
2471
|
+
kind: "RecordSet",
|
|
2472
|
+
names,
|
|
2473
|
+
sets: writtenIndexes.map((index) => writtenSets[index]),
|
|
2474
|
+
};
|
|
2475
|
+
};
|
|
1949
2476
|
}
|
|
1950
2477
|
case "Except":
|
|
1951
2478
|
return compileExcept(expression, environment);
|
|
@@ -1993,16 +2520,18 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
1993
2520
|
case "BoxAction":
|
|
1994
2521
|
case "AngleAction": {
|
|
1995
2522
|
const action = getChildEvaluator(expression.action);
|
|
1996
|
-
const unchanged = getChildEvaluator(
|
|
1997
|
-
kind: "Unchanged",
|
|
1998
|
-
expression: expression.subscript,
|
|
1999
|
-
location: expression.location,
|
|
2000
|
-
});
|
|
2523
|
+
const unchanged = compileUnchanged(getChildEvaluator(expression.subscript));
|
|
2001
2524
|
const isBox = expression.kind === "BoxAction";
|
|
2002
|
-
|
|
2003
|
-
|
|
2004
|
-
|
|
2005
|
-
|
|
2525
|
+
const form = isBox ? "[A]_e" : "<A>_e";
|
|
2526
|
+
return (context) => {
|
|
2527
|
+
const value = action(context);
|
|
2528
|
+
if (typeof value !== "boolean") {
|
|
2529
|
+
throw new TlaEvaluationError(
|
|
2530
|
+
`Attempted to evaluate an expression of form ${form}, but A was not a boolean.\n${describeRange(expression)}`,
|
|
2531
|
+
);
|
|
2532
|
+
}
|
|
2533
|
+
return isBox ? value || unchanged(context) : value && !unchanged(context);
|
|
2534
|
+
};
|
|
2006
2535
|
}
|
|
2007
2536
|
case "Enabled": {
|
|
2008
2537
|
const action = expression.expression;
|
|
@@ -2010,6 +2539,8 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2010
2539
|
}
|
|
2011
2540
|
case "Label":
|
|
2012
2541
|
return getChildEvaluator(expression.body);
|
|
2542
|
+
case "Selection":
|
|
2543
|
+
return getChildEvaluator(expression.expression);
|
|
2013
2544
|
case "Subexpression":
|
|
2014
2545
|
return () => {
|
|
2015
2546
|
throw new TlaEvaluationError(
|
|
@@ -2021,9 +2552,7 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2021
2552
|
case "WeakFairness":
|
|
2022
2553
|
case "StrongFairness":
|
|
2023
2554
|
return () => {
|
|
2024
|
-
throw
|
|
2025
|
-
`TLC cannot evaluate a temporal formula in a state at ${describeLocation(expression)}`,
|
|
2026
|
-
);
|
|
2555
|
+
throw createTemporalFormulaError(TEMPORAL_FORMS[expression.kind], expression);
|
|
2027
2556
|
};
|
|
2028
2557
|
}
|
|
2029
2558
|
};
|