tla-ts 0.0.9-dev.8298a52 → 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 +8 -0
- package/dist/compile.cjs +6 -6
- package/dist/compile.js +10 -10
- package/dist/deciders.cjs +41 -37
- package/dist/deciders.js +57 -53
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +121 -12
- package/dist/index.d.ts +121 -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 +1 -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 +1155 -900
- 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 +318 -656
- package/src/cli/typescript.ts +0 -3
- 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 +260 -371
- package/src/errors.ts +93 -58
- package/src/evaluate.ts +848 -374
- package/src/exit-codes.ts +63 -13
- package/src/fingerprints.ts +75 -11
- package/src/index.ts +3 -0
- package/src/instances.ts +97 -43
- 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 -325
- package/src/liveness.ts +224 -131
- 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 +34 -57
- package/src/parallel.ts +62 -72
- 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 +129 -38
- 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 +296 -105
- 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 +10 -25
- package/src/typescript/collections.ts +34 -35
- package/src/typescript/compile.ts +1 -8
- package/src/typescript/context.ts +0 -12
- package/src/typescript/emit.ts +0 -1
- package/src/typescript/expressions.ts +0 -12
- package/src/typescript/formula.ts +9 -15
- package/src/typescript/functions.ts +6 -17
- package/src/typescript/model.ts +14 -16
- package/src/typescript/names.ts +0 -2
- package/src/typescript/program.ts +0 -3
- package/src/typescript/properties.ts +6 -8
- package/src/typescript/scope.ts +0 -5
- package/src/typescript/steps.ts +20 -28
- package/src/typescript/types.ts +3 -10
- package/src/values.ts +917 -522
- 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,14 +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;
|
|
122
|
-
// Whether the thunk dropped its scope after caching a value that holds in every state.
|
|
123
144
|
isReleased?: boolean;
|
|
124
145
|
}
|
|
125
146
|
|
|
126
|
-
type Binding =
|
|
147
|
+
type Binding =
|
|
148
|
+
| { kind: "Value"; value: Value; argument?: Expression }
|
|
149
|
+
| Thunk
|
|
150
|
+
| { kind: "Operator"; operator: Operator };
|
|
127
151
|
|
|
128
152
|
export interface Scope {
|
|
129
153
|
name: string;
|
|
@@ -137,55 +161,37 @@ export interface Environment {
|
|
|
137
161
|
builtins: Map<string, Builtin>;
|
|
138
162
|
constants: Map<string, Value>;
|
|
139
163
|
substitutions: Map<string, string>;
|
|
140
|
-
// The name SANY gives each definition that a named instance such as `M == INSTANCE Module`
|
|
141
|
-
// copies, such as M!Op, by the key of the copy.
|
|
142
164
|
instanceNames: Map<string, string>;
|
|
143
165
|
variables: string[];
|
|
144
166
|
variableIndex: Map<string, number>;
|
|
145
167
|
facts: DefinitionFacts;
|
|
146
|
-
// The value of each constant definition TLC computed when it started, by the definition's id in
|
|
147
|
-
// facts. TLC evaluates a definition it failed to compute where the spec uses it.
|
|
148
168
|
startupValues: (Value | undefined)[];
|
|
149
|
-
|
|
150
|
-
// wraps the body of each in its substitutions.
|
|
169
|
+
tlcEvalValues: WeakMap<Expression, Value>;
|
|
151
170
|
substitutedDefinitions: Set<Definition>;
|
|
152
|
-
|
|
153
|
-
// code can serve, and of each reference to a definition.
|
|
171
|
+
instanceParams: Set<OperatorParam>;
|
|
154
172
|
evaluators: WeakMap<Expression, Evaluator>;
|
|
155
173
|
entryEvaluators: WeakMap<Expression, Evaluator>;
|
|
156
174
|
definitionEvaluators: WeakMap<Definition, Evaluator>;
|
|
157
|
-
// The expressions being evaluated, outermost first, when the environment replays an error to
|
|
158
|
-
// find where it occurred, as TLC's CallStackTool does.
|
|
159
175
|
callStack?: CallStack;
|
|
176
|
+
coverage?: Coverage;
|
|
160
177
|
}
|
|
161
178
|
|
|
162
179
|
export interface CallStack {
|
|
163
180
|
expressions: Expression[];
|
|
164
|
-
// TLC stops popping the stack once an evaluation fails, so it keeps where the failure occurred.
|
|
165
181
|
isFrozen: boolean;
|
|
166
|
-
// The expression that built each value of the replay that TLC's CallStackTool gives a source.
|
|
167
182
|
sources: WeakMap<ObjectValue, Expression>;
|
|
168
|
-
// The value each expression of the replay last evaluated to.
|
|
169
183
|
values: WeakMap<Expression, Value>;
|
|
170
|
-
// The expression each failure last left, which tells a failure of an operand from one of the
|
|
171
|
-
// method that computes the operator.
|
|
172
184
|
failures: WeakMap<Error, Expression>;
|
|
173
|
-
// The failure of a value with a source, which TLC raises as a FingerprintException.
|
|
174
185
|
fingerprint?: FingerprintFailure;
|
|
175
186
|
}
|
|
176
187
|
|
|
177
188
|
export interface FingerprintFailure {
|
|
178
|
-
// The sources of the values whose methods failed, outermost first.
|
|
179
189
|
sources: Expression[];
|
|
180
|
-
// The message of the error the innermost one raised.
|
|
181
190
|
reason: string;
|
|
182
191
|
}
|
|
183
192
|
|
|
184
|
-
// The operators of Tool#evalAppl whose value TLC's CallStackTool gives a source.
|
|
185
193
|
const SOURCED_OPERATORS = new Set(["SUBSET", "UNION", "DOMAIN", "\\cup", "\\cap", "\\"]);
|
|
186
194
|
|
|
187
|
-
// CallStackTool copies the SetPredValue, FcnLambdaValue and OpLambdaValue that an evaluation
|
|
188
|
-
// returns without their source, and a function TLC builds from a FcnLambdaValue has none.
|
|
189
195
|
const SOURCED_KINDS = new Set<Expression["kind"]>([
|
|
190
196
|
"SetEnumeration",
|
|
191
197
|
"SetFilter",
|
|
@@ -201,8 +207,6 @@ const isSourced = (expression: Expression) =>
|
|
|
201
207
|
SOURCED_KINDS.has(expression.kind) ||
|
|
202
208
|
(expression.kind === "Apply" && SOURCED_OPERATORS.has(expression.operator));
|
|
203
209
|
|
|
204
|
-
// The argument whose method Tool#evalAppl calls to compute an operator, as with S.member(e) for
|
|
205
|
-
// 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.
|
|
206
210
|
const getReceiver = (expression: Expression, values: CallStack["values"]) => {
|
|
207
211
|
if (expression.kind === "FunctionApplication" || expression.kind === "Except") {
|
|
208
212
|
return expression.function;
|
|
@@ -223,8 +227,6 @@ export interface Context {
|
|
|
223
227
|
scope: Scope | undefined;
|
|
224
228
|
state: State | undefined;
|
|
225
229
|
next: State | undefined;
|
|
226
|
-
// EvalControl.KeepLazy, which Tool#evalAppl sets to evaluate the function it applies and which
|
|
227
|
-
// the evaluation passes on, so that a function constructor within builds a FcnLambdaValue.
|
|
228
230
|
isKeepLazy?: boolean;
|
|
229
231
|
}
|
|
230
232
|
|
|
@@ -248,15 +250,23 @@ const EXCEPT_AT = "@";
|
|
|
248
250
|
export const describeLocation = (expression: Expression) =>
|
|
249
251
|
`line ${expression.location.line}, column ${expression.location.column}`;
|
|
250
252
|
|
|
251
|
-
export const formatRange = (range: SourceRange) =>
|
|
252
|
-
`line ${range.start.line}, col ${range.start.column} to line ${range.end.line}, col ${range.end.column} of module ${range.module}`;
|
|
253
|
-
|
|
254
253
|
export const describeRange = (expression: Expression) => {
|
|
255
254
|
const range = expression.location.range;
|
|
256
255
|
return range ? formatRange(range) : describeLocation(expression);
|
|
257
256
|
};
|
|
258
257
|
|
|
259
|
-
|
|
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
|
+
|
|
260
270
|
export const describeNode = (expression: Expression) =>
|
|
261
271
|
expression.kind === "Number"
|
|
262
272
|
? (expression.text ?? String(expression.value))
|
|
@@ -267,8 +277,6 @@ export const createConditionError = (expression: Expression, value: Value) =>
|
|
|
267
277
|
`A non-boolean expression (${getKindString(value)}) was used as the condition of an IF.\n${describeRange(expression)}`,
|
|
268
278
|
);
|
|
269
279
|
|
|
270
|
-
// TLC parses an infix chain of /\ or \/ as nested binary junctions and a bulleted list as one
|
|
271
|
-
// junction list, and it words the error differently for each.
|
|
272
280
|
export const createJunctionError = (
|
|
273
281
|
expression: Expression & { kind: "And" | "Or" },
|
|
274
282
|
index: number,
|
|
@@ -289,12 +297,10 @@ export const createJunctionError = (
|
|
|
289
297
|
);
|
|
290
298
|
};
|
|
291
299
|
|
|
292
|
-
// TLC selects a field of a record, and of another function from the function it converts it to,
|
|
293
|
-
// which for a tuple keeps its domain as an interval.
|
|
294
300
|
export const getFieldSelector = (expression: Expression & { kind: "FieldAccess" }) => {
|
|
295
301
|
const field = expression.field;
|
|
296
302
|
const describeMissing = (record: Value) =>
|
|
297
|
-
`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)}`;
|
|
298
304
|
const describeNotInDomain = (functionValue: Value) =>
|
|
299
305
|
`Attempted to apply function:\n${prettyPrint(formatValue(functionValue))}\nto argument "${field}", which is not in the domain of the function.`;
|
|
300
306
|
return (value: Value) => {
|
|
@@ -305,17 +311,14 @@ export const getFieldSelector = (expression: Expression & { kind: "FieldAccess"
|
|
|
305
311
|
}
|
|
306
312
|
const functionClass = getFunctionClass(value);
|
|
307
313
|
if (functionClass === "tuple") throw createNonIntegerKeyError(field);
|
|
308
|
-
// Only TLC's RecordValue names the field it lacks. Any other function, such as a FcnRcdValue
|
|
309
|
-
// whose keys are strings, reports an argument outside its domain.
|
|
310
314
|
return applyFunction(
|
|
311
|
-
value,
|
|
315
|
+
value.kind === "LazyFunction" ? toFiniteFunction(value) : value,
|
|
312
316
|
field,
|
|
313
317
|
functionClass === "record" ? describeMissing : describeNotInDomain,
|
|
314
318
|
);
|
|
315
319
|
};
|
|
316
320
|
};
|
|
317
321
|
|
|
318
|
-
// TLC 1.7.4 words what a tuple or a record lacks differently.
|
|
319
322
|
export const getMissingArgumentDescriber = (version: TlcVersion | undefined) =>
|
|
320
323
|
version === "1.7.4"
|
|
321
324
|
? (functionValue: Value, argument: Value) =>
|
|
@@ -332,41 +335,36 @@ export const getDomainOperator = (expression: Expression) => (value: Value) => {
|
|
|
332
335
|
};
|
|
333
336
|
|
|
334
337
|
export const getSubsetOperator =
|
|
335
|
-
(expression: Expression,
|
|
338
|
+
(expression: Expression, subset: (left: Value, right: Value) => Value) =>
|
|
339
|
+
(left: Value, right: Value) => {
|
|
336
340
|
if (!isSetValue(left) || isOverriddenSet(left)) {
|
|
337
341
|
throw new TlaEvaluationError(
|
|
338
342
|
`Attempted to evaluate an expression of form S \\subseteq T, but S was not enumerable.\n${describeRange(expression)}`,
|
|
339
343
|
);
|
|
340
344
|
}
|
|
341
|
-
return
|
|
345
|
+
return subset(left, right);
|
|
342
346
|
};
|
|
343
347
|
|
|
344
|
-
// TLC rejects a decimal, or an integer literal too big for it, while it processes the spec.
|
|
345
348
|
export const createRealNumberError = (expression: DecimalExpression) =>
|
|
346
349
|
setExitCode(
|
|
347
|
-
new TlaEvaluationError(
|
|
348
|
-
`TLC can't handle real numbers: ${expression.text} at ${describeLocation(expression)}`,
|
|
349
|
-
),
|
|
350
|
+
new TlaEvaluationError(`TLC can't handle real numbers.\n${expression.text}`),
|
|
350
351
|
EXIT_STATUS.configParseError,
|
|
351
352
|
);
|
|
352
353
|
|
|
353
354
|
export const createBigNumberError = (expression: NumberExpression) =>
|
|
354
355
|
setExitCode(
|
|
355
356
|
new TlaEvaluationError(
|
|
356
|
-
`TLC can't handle a number this big
|
|
357
|
+
`TLC can't handle a number this big.\n${expression.text ?? expression.value}`,
|
|
357
358
|
),
|
|
358
359
|
EXIT_STATUS.error,
|
|
359
360
|
);
|
|
360
361
|
|
|
361
|
-
// TLC's Tool#evalAppl fails to look up a variable the state doesn't assign.
|
|
362
362
|
export const createUnassignedError = (name: string, expression: Expression) =>
|
|
363
363
|
new TlaUnassignedError(
|
|
364
364
|
`In evaluation, the identifier ${name} is either undefined or not an operator.\n${describeRange(expression)}`,
|
|
365
365
|
name,
|
|
366
366
|
);
|
|
367
367
|
|
|
368
|
-
// TLC's Tool#enabled reads the subscript of <<A>>_v in the successor as a state of its own, and
|
|
369
|
-
// names the fairness condition when A leaves a variable of v unassigned, unlike TLC 1.7.4's.
|
|
370
368
|
export const toUnspecifiedSubscriptError = (error: unknown, version: TlcVersion | undefined) =>
|
|
371
369
|
error instanceof TlaUnassignedError && version !== "1.7.4"
|
|
372
370
|
? new TlaEvaluationError(
|
|
@@ -374,11 +372,6 @@ export const toUnspecifiedSubscriptError = (error: unknown, version: TlcVersion
|
|
|
374
372
|
)
|
|
375
373
|
: error;
|
|
376
374
|
|
|
377
|
-
export const createPrimeOutsideActionError = (expression: Expression) =>
|
|
378
|
-
new TlaEvaluationError(
|
|
379
|
-
`A primed expression appears outside an action at ${describeLocation(expression)}`,
|
|
380
|
-
);
|
|
381
|
-
|
|
382
375
|
export const lookupScope = (scope: Scope | undefined, name: string): Binding | undefined => {
|
|
383
376
|
for (let current = scope; current; current = current.parent) {
|
|
384
377
|
if (current.name === name) return current.binding;
|
|
@@ -392,12 +385,13 @@ export const bindValue = (scope: Scope | undefined, name: string, value: Value):
|
|
|
392
385
|
parent: scope,
|
|
393
386
|
});
|
|
394
387
|
|
|
395
|
-
const bindPattern = (scope: Scope | undefined, pattern: BoundPattern, value: Value) => {
|
|
388
|
+
export const bindPattern = (scope: Scope | undefined, pattern: BoundPattern, value: Value) => {
|
|
396
389
|
if (pattern.kind === "Name") return bindValue(scope, pattern.name, value);
|
|
397
390
|
const elements = getSequenceElements(value);
|
|
398
391
|
if (!elements || elements.length !== pattern.names.length) {
|
|
392
|
+
const range = pattern.ranges?.[0];
|
|
399
393
|
throw new TlaEvaluationError(
|
|
400
|
-
`
|
|
394
|
+
`Argument mismatch in operator application.${range ? formatRange(range) : ""}`,
|
|
401
395
|
);
|
|
402
396
|
}
|
|
403
397
|
return pattern.names.reduce<Scope | undefined>(
|
|
@@ -406,7 +400,6 @@ const bindPattern = (scope: Scope | undefined, pattern: BoundPattern, value: Val
|
|
|
406
400
|
);
|
|
407
401
|
};
|
|
408
402
|
|
|
409
|
-
// Tool#evalAppl checks that it applies a function before it evaluates the argument.
|
|
410
403
|
export const expectFunction = (value: Value, application: Expression) => {
|
|
411
404
|
if (isFunctionValue(value)) return value;
|
|
412
405
|
throw new TlaEvaluationError(
|
|
@@ -442,6 +435,42 @@ export const expectBoolean = (value: Value, description: string) => {
|
|
|
442
435
|
return value;
|
|
443
436
|
};
|
|
444
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
|
+
|
|
445
474
|
export const getDefinition = (name: string, environment: Environment) =>
|
|
446
475
|
environment.definitions.get(environment.substitutions.get(name) ?? name);
|
|
447
476
|
|
|
@@ -461,12 +490,9 @@ const getBoundExplanation = (set: Value, text: string) => {
|
|
|
461
490
|
return undefined;
|
|
462
491
|
};
|
|
463
492
|
|
|
464
|
-
// TLC enumerates every set except the ones it implements in Java, so any other set fails as its own
|
|
465
|
-
// class does.
|
|
466
493
|
const checkEnumerable = (set: Value, expression: Expression, version: TlcVersion) => {
|
|
467
494
|
if (!isSetValue(set) || isOverriddenSet(set)) {
|
|
468
495
|
const text = formatValue(set);
|
|
469
|
-
// TLC 1.7.4 doesn't explain why it can't enumerate a set.
|
|
470
496
|
const explanation = version === "1.7.4" ? undefined : getBoundExplanation(set, text);
|
|
471
497
|
throw new TlaEvaluationError(
|
|
472
498
|
explanation === undefined
|
|
@@ -482,16 +508,12 @@ const getEnumeratedElements = (set: Value, expression: Expression, version: TlcV
|
|
|
482
508
|
return getLazySubsets(set) ?? getNormalizedSetElements(set);
|
|
483
509
|
};
|
|
484
510
|
|
|
485
|
-
// The elements Tool.contexts binds to the bound of a quantifier or a set map. TLC 1.7.4 streams a
|
|
486
|
-
// lazy set's elements, where later versions normalize the set first.
|
|
487
511
|
export const getContextElements = (set: Value, expression: Expression, version: TlcVersion) => {
|
|
488
512
|
if (version !== "1.7.4") return getEnumeratedElements(set, expression, version);
|
|
489
513
|
checkEnumerable(set, expression, version);
|
|
490
514
|
return getLazySubsets(set) ?? getStreamedElements(set);
|
|
491
515
|
};
|
|
492
516
|
|
|
493
|
-
// Like TLC, a quantifier keeps an interval as an interval, so that it can stop at the first witness
|
|
494
|
-
// in a large interval such as 1..2000000000 without listing it.
|
|
495
517
|
const getKeptInterval = (set: Value) => {
|
|
496
518
|
if (typeof set !== "object" || set.kind !== "Interval") return undefined;
|
|
497
519
|
getCardinality(set);
|
|
@@ -501,7 +523,6 @@ const getKeptInterval = (set: Value) => {
|
|
|
501
523
|
export const getQuantifierElements = (set: Value, expression: Expression, version: TlcVersion) =>
|
|
502
524
|
getKeptInterval(set) ?? getContextElements(set, expression, version);
|
|
503
525
|
|
|
504
|
-
// CHOOSE and a function constructor visit the elements of the normalized set.
|
|
505
526
|
const getNormalizedElements = (set: Value, expression: Expression, version: TlcVersion) =>
|
|
506
527
|
getKeptInterval(set) ?? getEnumeratedElements(set, expression, version);
|
|
507
528
|
|
|
@@ -516,16 +537,22 @@ const someElement = (
|
|
|
516
537
|
return false;
|
|
517
538
|
};
|
|
518
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
|
+
|
|
519
551
|
export const getBoundElements = (bounds: Bound[], context: Context) =>
|
|
520
|
-
bounds
|
|
521
|
-
getQuantifierElements(
|
|
522
|
-
evaluate(bound.set, context),
|
|
523
|
-
bound.set,
|
|
524
|
-
context.environment.runtime.version,
|
|
525
|
-
),
|
|
552
|
+
mapBoundSets(bounds, (set) =>
|
|
553
|
+
getQuantifierElements(evaluate(set, context), set, context.environment.runtime.version),
|
|
526
554
|
);
|
|
527
555
|
|
|
528
|
-
// Visits each binding of the bounds to the elements of their sets, until visit returns true.
|
|
529
556
|
export const forEachBoundElement = (
|
|
530
557
|
bounds: Bound[],
|
|
531
558
|
sets: ReturnType<typeof getBoundElements>,
|
|
@@ -547,8 +574,33 @@ export const forEachBinding = (
|
|
|
547
574
|
visit: (scope: Scope | undefined) => boolean,
|
|
548
575
|
) => forEachBoundElement(bounds, getBoundElements(bounds, context), context.scope, visit);
|
|
549
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
|
+
|
|
550
602
|
const getBoundsDomain = (bounds: Bound[], context: Context): Value => {
|
|
551
|
-
const sets = bounds
|
|
603
|
+
const sets = mapBoundSets(bounds, (set) => evaluate(set, context));
|
|
552
604
|
return sets.length === 1 ? sets[0] : { kind: "ProductSet", factors: sets };
|
|
553
605
|
};
|
|
554
606
|
|
|
@@ -561,8 +613,6 @@ const bindArgument = (bounds: Bound[], scope: Scope | undefined, argument: Value
|
|
|
561
613
|
);
|
|
562
614
|
};
|
|
563
615
|
|
|
564
|
-
// The parameters, body and scope of each function a constructor or a definition keeps lazy, whose
|
|
565
|
-
// body TLC's getInitStates and getNextStates walk for an argument, as they do a FcnLambdaValue's.
|
|
566
616
|
interface LazyFunction {
|
|
567
617
|
value: LazyFunctionValue;
|
|
568
618
|
bounds: Bound[];
|
|
@@ -570,8 +620,7 @@ interface LazyFunction {
|
|
|
570
620
|
scope: Scope | undefined;
|
|
571
621
|
}
|
|
572
622
|
|
|
573
|
-
//
|
|
574
|
-
// 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.
|
|
575
624
|
interface KeptLazyFunctionValue extends LazyFunctionValue {
|
|
576
625
|
lambda: LazyFunction;
|
|
577
626
|
}
|
|
@@ -584,8 +633,6 @@ const keepLambda = (lambda: LazyFunction) => Object.assign(lambda.value, { lambd
|
|
|
584
633
|
export const getLazyFunction = (value: Value) =>
|
|
585
634
|
isKeptLazyFunction(value) ? value.lambda : undefined;
|
|
586
635
|
|
|
587
|
-
// Tool.getFcnContext: the scope of a lazy function's body for the arguments of an application. It
|
|
588
|
-
// ignores arguments beyond the parameters.
|
|
589
636
|
export const bindLazyArguments = (
|
|
590
637
|
lambda: LazyFunction,
|
|
591
638
|
expression: Expression & { kind: "FunctionApplication" },
|
|
@@ -610,12 +657,18 @@ export const bindLazyArguments = (
|
|
|
610
657
|
typeof value.domain === "object" && value.domain.kind === "ProductSet"
|
|
611
658
|
? value.domain.factors
|
|
612
659
|
: [];
|
|
613
|
-
if (elements === undefined
|
|
660
|
+
if (elements === undefined) {
|
|
614
661
|
throw new TlaEvaluationError(
|
|
615
662
|
`Attempted to apply a function to an argument not in its domain.\n${describeRange(expression.function)}`,
|
|
616
663
|
);
|
|
617
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
|
+
);
|
|
618
670
|
bounds.forEach((bound, index) => {
|
|
671
|
+
if (index >= elements.length) throw createListError();
|
|
619
672
|
const element = elements[index];
|
|
620
673
|
const ordinal = `argument number ${index + 1}`;
|
|
621
674
|
if (!isElementOf(element, domains[index])) {
|
|
@@ -636,11 +689,10 @@ export const bindLazyArguments = (
|
|
|
636
689
|
);
|
|
637
690
|
}
|
|
638
691
|
});
|
|
639
|
-
|
|
692
|
+
if (elements.length > bounds.length) throw createListError();
|
|
693
|
+
return bindArgument(bounds, lambda.scope, argument);
|
|
640
694
|
};
|
|
641
695
|
|
|
642
|
-
// TLC prints a function it can't enumerate as its parameters and the location of its body. It
|
|
643
|
-
// prints only the first name of a group such as `m, n \in S`.
|
|
644
696
|
interface LazyFunctionTemplate {
|
|
645
697
|
parameters: { index: number; name: string }[];
|
|
646
698
|
body: string;
|
|
@@ -663,7 +715,7 @@ const getLazyFunctionTemplate = (bounds: Bound[], body: Expression) => {
|
|
|
663
715
|
},
|
|
664
716
|
],
|
|
665
717
|
),
|
|
666
|
-
body:
|
|
718
|
+
body: describeNode(body),
|
|
667
719
|
};
|
|
668
720
|
};
|
|
669
721
|
|
|
@@ -686,22 +738,29 @@ const getLazyFunctionSource = (
|
|
|
686
738
|
};
|
|
687
739
|
};
|
|
688
740
|
|
|
689
|
-
// TLC's FcnLambdaValue evaluates its body at each application.
|
|
690
741
|
const createLazyFunction = (
|
|
691
742
|
domain: Value,
|
|
692
743
|
compute: (argument: Value, self: LazyFunctionValue) => Value,
|
|
693
744
|
source: LazyFunctionSource | undefined,
|
|
745
|
+
boundTupleLengths: (number | undefined)[] | undefined,
|
|
694
746
|
) => {
|
|
695
747
|
const self: LazyFunctionValue = {
|
|
696
748
|
kind: "LazyFunction",
|
|
697
749
|
domain,
|
|
698
750
|
source,
|
|
751
|
+
boundTupleLengths,
|
|
699
752
|
apply: (argument) => compute(argument, self),
|
|
700
753
|
};
|
|
701
754
|
return self;
|
|
702
755
|
};
|
|
703
756
|
|
|
704
|
-
|
|
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
|
+
|
|
705
764
|
const getDefinitionSource = (definition: FunctionDefinition): Expression => ({
|
|
706
765
|
kind: "FunctionConstruction",
|
|
707
766
|
bounds: definition.bounds,
|
|
@@ -709,7 +768,10 @@ const getDefinitionSource = (definition: FunctionDefinition): Expression => ({
|
|
|
709
768
|
location: definition.location,
|
|
710
769
|
});
|
|
711
770
|
|
|
712
|
-
const createRecursiveFunction = (
|
|
771
|
+
const createRecursiveFunction = (
|
|
772
|
+
definition: FunctionDefinition,
|
|
773
|
+
context: Context,
|
|
774
|
+
): RebindableLazyFunction => {
|
|
713
775
|
const domain = getBoundsDomain(definition.bounds, context);
|
|
714
776
|
const functionValue = createLazyFunction(
|
|
715
777
|
domain,
|
|
@@ -726,6 +788,7 @@ const createRecursiveFunction = (definition: FunctionDefinition, context: Contex
|
|
|
726
788
|
definition.bounds,
|
|
727
789
|
domain,
|
|
728
790
|
),
|
|
791
|
+
getBoundTupleLengths(definition.bounds),
|
|
729
792
|
);
|
|
730
793
|
keepLambda({
|
|
731
794
|
value: functionValue,
|
|
@@ -733,11 +796,16 @@ const createRecursiveFunction = (definition: FunctionDefinition, context: Contex
|
|
|
733
796
|
body: definition.body,
|
|
734
797
|
scope: bindValue(undefined, definition.name, functionValue),
|
|
735
798
|
});
|
|
736
|
-
|
|
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;
|
|
737
807
|
};
|
|
738
808
|
|
|
739
|
-
// TLC computes a constant definition when it starts, without keeping a function it constructs
|
|
740
|
-
// lazy, so a function over an interval or an enumerated set is a FcnRcdValue.
|
|
741
809
|
const toStartupValue = (definition: Definition, value: Value): Value => {
|
|
742
810
|
if (typeof value !== "object" || getFunctionClass(value) !== "lambda") return value;
|
|
743
811
|
if (
|
|
@@ -752,14 +820,11 @@ const toStartupValue = (definition: Definition, value: Value): Value => {
|
|
|
752
820
|
const finite = toFiniteFunction(value);
|
|
753
821
|
return createSortedFunction(finite.domain, finite.range);
|
|
754
822
|
} catch (error) {
|
|
755
|
-
// TLC leaves a definition it fails to compute to evaluate where the spec uses it.
|
|
756
823
|
if (error instanceof TlaEvaluationError) return value;
|
|
757
824
|
throw error;
|
|
758
825
|
}
|
|
759
826
|
};
|
|
760
827
|
|
|
761
|
-
// The code of a definition's body, evaluated as a whole. TLC evaluates a function definition that
|
|
762
|
-
// isn't recursive as it does a function constructor.
|
|
763
828
|
const compileDefinitionBody = (definition: Definition, environment: Environment): Evaluator => {
|
|
764
829
|
if (definition.kind === "Operator" && definition.params.length > 0) {
|
|
765
830
|
return () => {
|
|
@@ -774,57 +839,92 @@ const compileDefinitionBody = (definition: Definition, environment: Environment)
|
|
|
774
839
|
return getEntryEvaluator(getDefinitionSource(definition), environment);
|
|
775
840
|
};
|
|
776
841
|
|
|
777
|
-
|
|
778
|
-
|
|
842
|
+
const CALLER_SCOPE: Scope = {
|
|
843
|
+
name: "",
|
|
844
|
+
binding: { kind: "Value", value: false },
|
|
845
|
+
parent: undefined,
|
|
846
|
+
};
|
|
847
|
+
|
|
779
848
|
const getDefinitionEvaluator = (definition: Definition, environment: Environment): Evaluator => {
|
|
780
849
|
const compiled = environment.definitionEvaluators.get(definition);
|
|
781
850
|
if (compiled) return compiled;
|
|
782
851
|
const body = compileDefinitionBody(definition, environment);
|
|
783
|
-
const
|
|
852
|
+
const definitionId = environment.facts.ids.get(definition);
|
|
784
853
|
const startupValues = environment.startupValues;
|
|
785
|
-
const
|
|
786
|
-
|
|
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
|
|
787
863
|
? (context) => body(withScope(context, undefined))
|
|
788
|
-
: (context) => startupValues[
|
|
864
|
+
: (context) => startupValues[definitionId] ?? body(withScope(context, undefined));
|
|
789
865
|
environment.definitionEvaluators.set(definition, evaluator);
|
|
790
866
|
return evaluator;
|
|
791
867
|
};
|
|
792
868
|
|
|
793
869
|
export const getStartupValue = (definition: Definition, environment: Environment) => {
|
|
794
|
-
const
|
|
795
|
-
return
|
|
870
|
+
const definitionId = environment.facts.ids.get(definition);
|
|
871
|
+
return definitionId === undefined ? undefined : environment.startupValues[definitionId];
|
|
796
872
|
};
|
|
797
873
|
|
|
798
|
-
// TLC computes each constant definition the configuration doesn't replace when it starts, and
|
|
799
|
-
// leaves one it fails to compute to evaluate where the spec uses it.
|
|
800
874
|
export const evaluateStartupDefinitions = (definitions: Definition[], environment: Environment) =>
|
|
801
875
|
definitions.forEach((definition) => {
|
|
802
876
|
if (definition.kind === "Operator" && definition.params.length > 0) return;
|
|
803
877
|
const name = definition.name;
|
|
804
878
|
if (environment.constants.has(name) || environment.substitutions.has(name)) return;
|
|
805
|
-
if (!
|
|
806
|
-
const
|
|
807
|
-
if (
|
|
879
|
+
if (!isEvaluatedAtStartup(definition, environment)) return;
|
|
880
|
+
const definitionId = environment.facts.ids.get(definition);
|
|
881
|
+
if (definitionId === undefined || environment.startupValues[definitionId] !== undefined) return;
|
|
808
882
|
const context = { environment, scope: undefined, state: undefined, next: undefined };
|
|
809
883
|
try {
|
|
810
884
|
const value = environment.runtime.evaluateAtStartup(() =>
|
|
811
885
|
toStartupValue(definition, compileDefinitionBody(definition, environment)(context)),
|
|
812
886
|
);
|
|
813
887
|
markNormalized(value);
|
|
814
|
-
environment.startupValues[
|
|
888
|
+
environment.startupValues[definitionId] = value;
|
|
815
889
|
} catch (error) {
|
|
816
890
|
// TLC swallows whatever the definition throws, a stack overflow included.
|
|
817
891
|
if (!(error instanceof TlaEvaluationError) && !isStackOverflow(error)) throw error;
|
|
818
892
|
}
|
|
819
893
|
});
|
|
820
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
|
+
|
|
821
908
|
const forceThunk = (thunk: Thunk, context: Context) => {
|
|
822
|
-
const
|
|
823
|
-
|
|
824
|
-
|
|
825
|
-
|
|
826
|
-
|
|
827
|
-
|
|
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
|
+
}
|
|
828
928
|
if (thunk.cache !== undefined && thunk.state === undefined && thunk.next === undefined) {
|
|
829
929
|
thunk.scope = undefined;
|
|
830
930
|
thunk.isReleased = true;
|
|
@@ -832,7 +932,7 @@ const forceThunk = (thunk: Thunk, context: Context) => {
|
|
|
832
932
|
return value;
|
|
833
933
|
};
|
|
834
934
|
|
|
835
|
-
const getDefinitionClosure = (definition: Definition & { kind: "Operator" }): Closure => ({
|
|
935
|
+
export const getDefinitionClosure = (definition: Definition & { kind: "Operator" }): Closure => ({
|
|
836
936
|
kind: "Closure",
|
|
837
937
|
name: definition.name,
|
|
838
938
|
params: definition.params,
|
|
@@ -896,6 +996,12 @@ const evaluateOperatorArgument = (expression: Expression, context: Context): Ope
|
|
|
896
996
|
};
|
|
897
997
|
|
|
898
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
|
+
}
|
|
899
1005
|
if (operator.kind === "Builtin") return operator.evaluate(args, context);
|
|
900
1006
|
if (operator.kind === "Operator") return operator.call(args);
|
|
901
1007
|
const scope = operator.params.reduce<Scope | undefined>(
|
|
@@ -913,11 +1019,6 @@ const toOperatorValue = (operator: Operator, context: Context): OperatorValue =>
|
|
|
913
1019
|
name: operator.name,
|
|
914
1020
|
arity: getArity(operator),
|
|
915
1021
|
call: (args) => callOperatorWithValues(operator, args, context),
|
|
916
|
-
literalBody:
|
|
917
|
-
operator.kind === "Closure" &&
|
|
918
|
-
(operator.body.kind === "Number" || operator.body.kind === "String")
|
|
919
|
-
? operator.body.value
|
|
920
|
-
: undefined,
|
|
921
1022
|
};
|
|
922
1023
|
|
|
923
1024
|
const isOperatorArgument = (expression: Expression, context: Context) => {
|
|
@@ -927,6 +1028,7 @@ const isOperatorArgument = (expression: Expression, context: Context) => {
|
|
|
927
1028
|
return operator !== undefined && getArity(operator) > 0;
|
|
928
1029
|
};
|
|
929
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.
|
|
930
1032
|
const evaluateBuiltinArguments = (args: Expression[], context: Context) =>
|
|
931
1033
|
args.map((arg) =>
|
|
932
1034
|
isOperatorArgument(arg, context)
|
|
@@ -969,9 +1071,17 @@ const compileArgumentBinder = (argument: Expression, environment: Environment):
|
|
|
969
1071
|
const isLiteral =
|
|
970
1072
|
argument.kind === "String" || (argument.kind === "Number" && isTlcInteger(argument.value));
|
|
971
1073
|
if (isLiteral) {
|
|
972
|
-
const binding: Binding = { kind: "Value", value: argument.value };
|
|
1074
|
+
const binding: Binding = { kind: "Value", value: argument.value, argument };
|
|
973
1075
|
return () => binding;
|
|
974
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
|
+
}
|
|
975
1085
|
if (argument.kind === "Identifier") {
|
|
976
1086
|
const global = isLocallyResolved(argument)
|
|
977
1087
|
? undefined
|
|
@@ -980,7 +1090,7 @@ const compileArgumentBinder = (argument: Expression, environment: Environment):
|
|
|
980
1090
|
const binding: Binding = { kind: "Value", value: global.value };
|
|
981
1091
|
return () => binding;
|
|
982
1092
|
}
|
|
983
|
-
if (global === undefined) {
|
|
1093
|
+
if (global === undefined && !environment.callStack) {
|
|
984
1094
|
return (context) => {
|
|
985
1095
|
const binding = lookupScope(context.scope, argument.name);
|
|
986
1096
|
return binding?.kind === "Value" || binding?.kind === "Thunk"
|
|
@@ -1028,14 +1138,11 @@ const callOperator = (
|
|
|
1028
1138
|
return operator.evaluate(evaluateBuiltinArguments(args, context), context);
|
|
1029
1139
|
};
|
|
1030
1140
|
|
|
1031
|
-
// The LET definitions that a reference evaluates again, and those that cache only a settled value.
|
|
1032
1141
|
interface ReevaluatedDefinitions {
|
|
1033
1142
|
impure: ReadonlySet<Definition>;
|
|
1034
1143
|
streamed: ReadonlySet<Definition>;
|
|
1035
1144
|
}
|
|
1036
1145
|
|
|
1037
|
-
// A LET's function definition has one function constructor, as in SANY, so its code compiles once
|
|
1038
|
-
// however often the LET is evaluated.
|
|
1039
1146
|
const letFunctionConstructions = new WeakMap<FunctionDefinition, Expression>();
|
|
1040
1147
|
|
|
1041
1148
|
const getLetFunctionConstruction = (definition: FunctionDefinition): Expression => {
|
|
@@ -1056,49 +1163,65 @@ export const bindDefinitions = (
|
|
|
1056
1163
|
definitions: Definition[],
|
|
1057
1164
|
context: Context,
|
|
1058
1165
|
reevaluated?: ReevaluatedDefinitions,
|
|
1059
|
-
): Scope | undefined =>
|
|
1060
|
-
definitions.
|
|
1061
|
-
|
|
1062
|
-
|
|
1063
|
-
|
|
1064
|
-
|
|
1065
|
-
|
|
1066
|
-
|
|
1067
|
-
node.binding = {
|
|
1068
|
-
kind: "Thunk",
|
|
1069
|
-
expression: getLetFunctionConstruction(definition),
|
|
1070
|
-
scope: node,
|
|
1071
|
-
state: context.state,
|
|
1072
|
-
next: context.next,
|
|
1073
|
-
cache: undefined,
|
|
1074
|
-
isStreamed: false,
|
|
1075
|
-
};
|
|
1076
|
-
return node;
|
|
1077
|
-
}
|
|
1078
|
-
if (definition.params.length > 0 || reevaluated?.impure.has(definition)) {
|
|
1079
|
-
node.binding = {
|
|
1080
|
-
kind: "Operator",
|
|
1081
|
-
operator: {
|
|
1082
|
-
kind: "Closure",
|
|
1083
|
-
name: definition.name,
|
|
1084
|
-
params: definition.params,
|
|
1085
|
-
body: definition.body,
|
|
1086
|
-
scope: node,
|
|
1087
|
-
},
|
|
1088
|
-
};
|
|
1089
|
-
return node;
|
|
1090
|
-
}
|
|
1091
|
-
node.binding = {
|
|
1092
|
-
kind: "Thunk",
|
|
1093
|
-
expression: definition.body,
|
|
1094
|
-
scope: node,
|
|
1095
|
-
state: context.state,
|
|
1096
|
-
next: context.next,
|
|
1097
|
-
cache: undefined,
|
|
1098
|
-
isStreamed: reevaluated?.streamed.has(definition) ?? false,
|
|
1099
|
-
};
|
|
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;
|
|
1100
1174
|
return node;
|
|
1101
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
|
+
};
|
|
1102
1225
|
|
|
1103
1226
|
const evaluateLocalIdentifier = (name: string, expression: Expression, context: Context): Value => {
|
|
1104
1227
|
const binding = lookupScope(context.scope, name);
|
|
@@ -1120,19 +1243,22 @@ const evaluateLocalIdentifier = (name: string, expression: Expression, context:
|
|
|
1120
1243
|
if (global?.kind === "Definition") {
|
|
1121
1244
|
return getDefinitionEvaluator(global.definition, context.environment)(context);
|
|
1122
1245
|
}
|
|
1123
|
-
const builtin = context.environment.builtins.get(
|
|
1246
|
+
const builtin = context.environment.builtins.get(
|
|
1247
|
+
context.environment.substitutions.get(name) ?? name,
|
|
1248
|
+
);
|
|
1124
1249
|
if (builtin?.arity === 0) return builtin.evaluate([], context);
|
|
1125
|
-
throw new TlaEvaluationError(
|
|
1250
|
+
throw new TlaEvaluationError(
|
|
1251
|
+
`In evaluation, the identifier ${name} is either undefined or not an operator.\n${describeRange(expression)}`,
|
|
1252
|
+
);
|
|
1126
1253
|
};
|
|
1127
1254
|
|
|
1128
|
-
// TLC's next-state generator does not bind LET definitions to values, so each reference to one
|
|
1129
|
-
// evaluates it again: one that calls an impure builtin repeats its effects, and a set one builds
|
|
1130
|
-
// with UNION or \cup starts out uncached.
|
|
1131
1255
|
export const getReevaluatedDefinitions = (
|
|
1132
1256
|
definitions: Definition[],
|
|
1133
1257
|
environment: Environment,
|
|
1134
1258
|
): ReevaluatedDefinitions => ({
|
|
1135
|
-
impure: new Set(
|
|
1259
|
+
impure: new Set(
|
|
1260
|
+
definitions.filter((definition) => isImpureDefinition(definition, environment, "varying")),
|
|
1261
|
+
),
|
|
1136
1262
|
streamed: new Set(
|
|
1137
1263
|
definitions.filter((definition) => isImpureDefinition(definition, environment, "streamed")),
|
|
1138
1264
|
),
|
|
@@ -1143,23 +1269,39 @@ export const isImpure = (environment: Environment) =>
|
|
|
1143
1269
|
isImpureDefinition(definition, environment),
|
|
1144
1270
|
);
|
|
1145
1271
|
|
|
1146
|
-
// Whether evaluating a definition again can show, such as by printing twice.
|
|
1147
1272
|
export const hasRepeatedEffects = (environment: Environment) =>
|
|
1148
1273
|
[...environment.facts.ids.keys()].some((definition) =>
|
|
1149
1274
|
isImpureDefinition(definition, environment, "repeated"),
|
|
1150
1275
|
);
|
|
1151
1276
|
|
|
1152
|
-
// A set filter TLC evaluates lazily, with how to rebuild it so that its predicate runs in another
|
|
1153
|
-
// environment.
|
|
1154
1277
|
interface RebindableFilteredSet extends FilteredSetValue {
|
|
1155
1278
|
rebind: (environment: Environment) => Value;
|
|
1156
1279
|
}
|
|
1157
1280
|
|
|
1158
|
-
|
|
1159
|
-
|
|
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
|
+
};
|
|
1160
1304
|
|
|
1161
|
-
// TLC's CallStackTool rebinds the lazy values its evaluations return, so their later evaluation
|
|
1162
|
-
// records its call stack too.
|
|
1163
1305
|
const traceEvaluator =
|
|
1164
1306
|
(
|
|
1165
1307
|
expression: Expression,
|
|
@@ -1177,13 +1319,17 @@ const traceEvaluator =
|
|
|
1177
1319
|
setTrace.callStack = callStack;
|
|
1178
1320
|
try {
|
|
1179
1321
|
const computed = evaluator(context);
|
|
1180
|
-
const value =
|
|
1322
|
+
const value = isRebindable(computed) ? computed.rebind(environment) : computed;
|
|
1181
1323
|
callStack.values.set(expression, value);
|
|
1182
1324
|
if (typeof value === "object" && value.kind !== "FilteredSet" && isSourced(expression)) {
|
|
1183
1325
|
callStack.sources.set(value, expression);
|
|
1184
1326
|
}
|
|
1185
1327
|
return value;
|
|
1186
1328
|
} catch (error) {
|
|
1329
|
+
if (error instanceof TlaSetBoundError && !callStack.isFrozen) {
|
|
1330
|
+
callStack.expressions.length = 0;
|
|
1331
|
+
callStack.isFrozen = true;
|
|
1332
|
+
}
|
|
1187
1333
|
const failed = error instanceof Error ? callStack.failures.get(error) : undefined;
|
|
1188
1334
|
if (error instanceof Error) callStack.failures.set(error, expression);
|
|
1189
1335
|
const receiver = getReceiver(expression, callStack.values);
|
|
@@ -1211,20 +1357,15 @@ const traceEvaluator =
|
|
|
1211
1357
|
}
|
|
1212
1358
|
};
|
|
1213
1359
|
|
|
1214
|
-
// A method of a value with a source raises a FingerprintException, which each value with a source
|
|
1215
|
-
// whose method called it heads in turn. CallStack#freeze adds their sources to the stack, outermost
|
|
1216
|
-
// first. The values are those whose methods failed, outermost first.
|
|
1217
1360
|
export const freezeCallStack = (
|
|
1218
1361
|
callStack: CallStack,
|
|
1219
1362
|
values: (Value | undefined)[],
|
|
1220
1363
|
error: unknown,
|
|
1221
1364
|
) => {
|
|
1222
|
-
// A set that streams its elements enumerates itself too, so it can appear twice.
|
|
1223
1365
|
const sources = [...new Set(values)].flatMap((item) => {
|
|
1224
1366
|
const source = typeof item === "object" ? callStack.sources.get(item) : undefined;
|
|
1225
1367
|
return source ? [source] : [];
|
|
1226
1368
|
});
|
|
1227
|
-
// A value with a source raises a FingerprintException even when the stack is frozen already.
|
|
1228
1369
|
if (sources.length > 0 && error instanceof TlaEvaluationError) {
|
|
1229
1370
|
if (!callStack.isFrozen) callStack.expressions.push(...sources);
|
|
1230
1371
|
const inner = callStack.fingerprint;
|
|
@@ -1236,8 +1377,6 @@ export const freezeCallStack = (
|
|
|
1236
1377
|
callStack.isFrozen = true;
|
|
1237
1378
|
};
|
|
1238
1379
|
|
|
1239
|
-
// A FingerprintException that a method of a value with a source raises, or that passes through one,
|
|
1240
|
-
// takes the value's source as its new head.
|
|
1241
1380
|
const headFingerprint = (callStack: CallStack, source: Expression, error: unknown) => {
|
|
1242
1381
|
if (!(error instanceof TlaEvaluationError)) return;
|
|
1243
1382
|
if (!callStack.isFrozen) callStack.expressions.push(source);
|
|
@@ -1249,8 +1388,6 @@ const headFingerprint = (callStack: CallStack, source: Expression, error: unknow
|
|
|
1249
1388
|
};
|
|
1250
1389
|
};
|
|
1251
1390
|
|
|
1252
|
-
// A copy of the environment that records the call stack of each evaluation, with evaluators of its
|
|
1253
|
-
// own since the environment's evaluators record nothing.
|
|
1254
1391
|
export const createTracingEnvironment = (environment: Environment): Environment => ({
|
|
1255
1392
|
...environment,
|
|
1256
1393
|
evaluators: new WeakMap(),
|
|
@@ -1265,20 +1402,107 @@ export const createTracingEnvironment = (environment: Environment): Environment
|
|
|
1265
1402
|
},
|
|
1266
1403
|
});
|
|
1267
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
|
+
|
|
1268
1488
|
export const getEvaluator = (expression: Expression, environment: Environment): Evaluator => {
|
|
1269
1489
|
const cached = environment.evaluators.get(expression);
|
|
1270
1490
|
if (cached) return cached;
|
|
1271
1491
|
const compiled = compile(expression, environment);
|
|
1272
1492
|
const callStack = environment.callStack;
|
|
1273
|
-
const
|
|
1493
|
+
const frames = callStack && substitutionFrames.get(expression);
|
|
1494
|
+
const traced = callStack
|
|
1274
1495
|
? traceEvaluator(expression, compiled, environment, callStack)
|
|
1275
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;
|
|
1276
1500
|
environment.evaluators.set(expression, evaluator);
|
|
1277
1501
|
return evaluator;
|
|
1278
1502
|
};
|
|
1279
1503
|
|
|
1280
1504
|
export const getEntryEvaluator = (expression: Expression, environment: Environment) => {
|
|
1281
|
-
if (environment.callStack) return getEvaluator(expression, environment);
|
|
1505
|
+
if (environment.callStack || environment.coverage) return getEvaluator(expression, environment);
|
|
1282
1506
|
const compiled = environment.entryEvaluators.get(expression);
|
|
1283
1507
|
if (compiled) return compiled;
|
|
1284
1508
|
const evaluator =
|
|
@@ -1309,12 +1533,9 @@ const compileIdentifier = (
|
|
|
1309
1533
|
return () => value;
|
|
1310
1534
|
}
|
|
1311
1535
|
if (global?.kind === "Definition") {
|
|
1312
|
-
// The body compiles when the reference is first evaluated, as a recursive definition's body
|
|
1313
|
-
// refers back to it.
|
|
1314
1536
|
const definition = global.definition;
|
|
1315
|
-
|
|
1316
|
-
return (context) =>
|
|
1317
|
-
(compiled.reference ??= getDefinitionEvaluator(definition, environment))(context);
|
|
1537
|
+
let compiled: Evaluator | undefined;
|
|
1538
|
+
return (context) => (compiled ??= getDefinitionEvaluator(definition, environment))(context);
|
|
1318
1539
|
}
|
|
1319
1540
|
return (context) => evaluateLocalIdentifier(name, expression, context);
|
|
1320
1541
|
};
|
|
@@ -1394,11 +1615,10 @@ const compileClosureCall = (
|
|
|
1394
1615
|
environment: Environment,
|
|
1395
1616
|
): Evaluator => {
|
|
1396
1617
|
const bindArguments = compileArgumentScope(closure, args, environment);
|
|
1397
|
-
|
|
1398
|
-
const compiled = { body: undefined as Evaluator | undefined };
|
|
1618
|
+
let body: Evaluator | undefined;
|
|
1399
1619
|
return (context) => {
|
|
1400
|
-
|
|
1401
|
-
return
|
|
1620
|
+
body ??= getEntryEvaluator(closure.body, environment);
|
|
1621
|
+
return body({
|
|
1402
1622
|
environment,
|
|
1403
1623
|
scope: bindArguments(context),
|
|
1404
1624
|
state: context.state,
|
|
@@ -1408,6 +1628,26 @@ const compileClosureCall = (
|
|
|
1408
1628
|
};
|
|
1409
1629
|
};
|
|
1410
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
|
+
|
|
1411
1651
|
const compileApply = (
|
|
1412
1652
|
expression: Expression & { kind: "Apply" },
|
|
1413
1653
|
environment: Environment,
|
|
@@ -1417,12 +1657,24 @@ const compileApply = (
|
|
|
1417
1657
|
const left = getEvaluator(args[0], environment);
|
|
1418
1658
|
const right = getEvaluator(args[1], environment);
|
|
1419
1659
|
return (context) =>
|
|
1420
|
-
!
|
|
1421
|
-
|
|
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);
|
|
1422
1666
|
}
|
|
1423
|
-
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 === "-+->") {
|
|
1424
1673
|
return () => {
|
|
1425
|
-
throw
|
|
1674
|
+
throw createTemporalFormulaError(
|
|
1675
|
+
expression.operator === "~>" ? "a ~> b" : "a -+-> formula",
|
|
1676
|
+
expression,
|
|
1677
|
+
);
|
|
1426
1678
|
};
|
|
1427
1679
|
}
|
|
1428
1680
|
const global = isLocallyResolved(expression)
|
|
@@ -1434,23 +1686,66 @@ const compileApply = (
|
|
|
1434
1686
|
const domain = getDomainOperator(expression);
|
|
1435
1687
|
return (context) => domain(operand(context));
|
|
1436
1688
|
}
|
|
1437
|
-
// TLC sorts the value of a constant TLCEval argument only where no context binds a name.
|
|
1438
1689
|
if (global?.kind === "Builtin" && global.name === "TLCEval" && args.length === 1) {
|
|
1439
|
-
|
|
1440
|
-
|
|
1441
|
-
|
|
1442
|
-
|
|
1443
|
-
return (context) =>
|
|
1444
|
-
|
|
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
|
+
};
|
|
1445
1704
|
}
|
|
1446
|
-
if (
|
|
1705
|
+
if (
|
|
1706
|
+
global?.kind === "Builtin" &&
|
|
1707
|
+
global.name === "\\subseteq" &&
|
|
1708
|
+
global.evaluateBinary &&
|
|
1709
|
+
args.length === 2
|
|
1710
|
+
) {
|
|
1447
1711
|
const left = getEvaluator(args[0], environment);
|
|
1448
1712
|
const right = getEvaluator(args[1], environment);
|
|
1449
|
-
const subset = getSubsetOperator(expression, global);
|
|
1450
|
-
|
|
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
|
+
};
|
|
1451
1747
|
}
|
|
1452
1748
|
if (global?.kind === "Builtin") return compileBuiltinCall(global, args, environment);
|
|
1453
|
-
// TLC refuses action composition unless a Java property enables its incomplete implementation.
|
|
1454
1749
|
if (expression.operator === "\\cdot" && args.length === 2) {
|
|
1455
1750
|
return () => {
|
|
1456
1751
|
throw new TlaEvaluationError(
|
|
@@ -1479,9 +1774,20 @@ const compileQuantifier = (
|
|
|
1479
1774
|
environment: Environment,
|
|
1480
1775
|
): Evaluator => {
|
|
1481
1776
|
const isForall = expression.kind === "Forall";
|
|
1482
|
-
const description = isForall ? "the body of \\A" : "the body of \\E";
|
|
1483
1777
|
const body = getEvaluator(expression.body, environment);
|
|
1484
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
|
+
}
|
|
1485
1791
|
if (expression.bounds.length === 1 && bound.pattern.kind === "Name") {
|
|
1486
1792
|
const name = bound.pattern.name;
|
|
1487
1793
|
const set = getEvaluator(bound.set, environment);
|
|
@@ -1489,9 +1795,9 @@ const compileQuantifier = (
|
|
|
1489
1795
|
const isFound = someElement(
|
|
1490
1796
|
getQuantifierElements(set(context), bound.set, environment.runtime.version),
|
|
1491
1797
|
(element) =>
|
|
1492
|
-
|
|
1798
|
+
expectBooleanBody(
|
|
1493
1799
|
body(withScope(context, bindValue(context.scope, name, element))),
|
|
1494
|
-
|
|
1800
|
+
expression,
|
|
1495
1801
|
) !== isForall,
|
|
1496
1802
|
);
|
|
1497
1803
|
return isFound ? !isForall : isForall;
|
|
@@ -1500,14 +1806,17 @@ const compileQuantifier = (
|
|
|
1500
1806
|
const bounds = expression.bounds;
|
|
1501
1807
|
if (bounds.every((item) => item.pattern.kind === "Name")) {
|
|
1502
1808
|
const names = bounds.map((item) => (item.pattern.kind === "Name" ? item.pattern.name : ""));
|
|
1503
|
-
const sets = bounds.map((item) => getEvaluator(item.set, environment));
|
|
1504
1809
|
return (context) => {
|
|
1505
|
-
const lists =
|
|
1506
|
-
getQuantifierElements(
|
|
1810
|
+
const lists = mapBoundSets(bounds, (set) =>
|
|
1811
|
+
getQuantifierElements(
|
|
1812
|
+
getEvaluator(set, environment)(context),
|
|
1813
|
+
set,
|
|
1814
|
+
environment.runtime.version,
|
|
1815
|
+
),
|
|
1507
1816
|
);
|
|
1508
1817
|
const visit = (index: number, scope: Scope | undefined): boolean => {
|
|
1509
1818
|
if (index < 0) {
|
|
1510
|
-
return
|
|
1819
|
+
return expectBooleanBody(body(withScope(context, scope)), expression) !== isForall;
|
|
1511
1820
|
}
|
|
1512
1821
|
return someElement(lists[index], (element) =>
|
|
1513
1822
|
visit(index - 1, bindValue(scope, names[index], element)),
|
|
@@ -1520,7 +1829,7 @@ const compileQuantifier = (
|
|
|
1520
1829
|
const isFound = forEachBinding(
|
|
1521
1830
|
bounds,
|
|
1522
1831
|
context,
|
|
1523
|
-
(scope) =>
|
|
1832
|
+
(scope) => expectBooleanBody(body(withScope(context, scope)), expression) !== isForall,
|
|
1524
1833
|
);
|
|
1525
1834
|
return isFound ? !isForall : isForall;
|
|
1526
1835
|
};
|
|
@@ -1539,8 +1848,6 @@ const getBoundValue = (pattern: BoundPattern, scope: Scope | undefined) => {
|
|
|
1539
1848
|
return binding?.kind === "Value" ? binding.value : undefined;
|
|
1540
1849
|
};
|
|
1541
1850
|
|
|
1542
|
-
// TLC keeps a function constructor lazy when it is the function of an application, or the base of
|
|
1543
|
-
// an EXCEPT that is, so it evaluates the body only at the arguments it is applied to.
|
|
1544
1851
|
const keptLazyExpressions = new WeakSet<Expression>();
|
|
1545
1852
|
|
|
1546
1853
|
export const keepLazy = (expression: Expression) => {
|
|
@@ -1549,8 +1856,6 @@ export const keepLazy = (expression: Expression) => {
|
|
|
1549
1856
|
}
|
|
1550
1857
|
};
|
|
1551
1858
|
|
|
1552
|
-
// The names an expression may look up in its scope, or undefined when a subexpression selector may
|
|
1553
|
-
// look up others.
|
|
1554
1859
|
const scopeNames = new WeakMap<Expression, string[] | undefined>();
|
|
1555
1860
|
|
|
1556
1861
|
const getScopeNames = (expression: Expression) => {
|
|
@@ -1558,8 +1863,8 @@ const getScopeNames = (expression: Expression) => {
|
|
|
1558
1863
|
const names = new Set<string>();
|
|
1559
1864
|
const visit = (node: Expression): boolean => {
|
|
1560
1865
|
if (node.kind === "Subexpression") return false;
|
|
1561
|
-
|
|
1562
|
-
if (
|
|
1866
|
+
const name = getReferencedName(node);
|
|
1867
|
+
if (name !== undefined) names.add(name);
|
|
1563
1868
|
if (node.kind === "ExceptAt") names.add(EXCEPT_AT);
|
|
1564
1869
|
return getChildren(node).every(visit);
|
|
1565
1870
|
};
|
|
@@ -1568,9 +1873,6 @@ const getScopeNames = (expression: Expression) => {
|
|
|
1568
1873
|
return result;
|
|
1569
1874
|
};
|
|
1570
1875
|
|
|
1571
|
-
// The bindings of a scope that names look up, so that a lazy function keeps only those alive and
|
|
1572
|
-
// not the values its other bindings cached. An unnamed node ends the chain, since a TLCEval in the
|
|
1573
|
-
// body sorts its value only where no context binds a name.
|
|
1574
1876
|
const trimScope = (scope: Scope | undefined, names: string[] | undefined) =>
|
|
1575
1877
|
names === undefined || scope === undefined
|
|
1576
1878
|
? scope
|
|
@@ -1582,32 +1884,41 @@ const trimScope = (scope: Scope | undefined, names: string[] | undefined) =>
|
|
|
1582
1884
|
{ name: "", binding: { kind: "Value", value: false }, parent: undefined },
|
|
1583
1885
|
);
|
|
1584
1886
|
|
|
1585
|
-
const
|
|
1887
|
+
export const isKeptLazy = (expression: Expression) => keptLazyExpressions.has(expression);
|
|
1888
|
+
|
|
1889
|
+
export const getFunctionBuilder = (
|
|
1586
1890
|
expression: Expression & { kind: "FunctionConstruction" },
|
|
1587
1891
|
environment: Environment,
|
|
1588
|
-
)
|
|
1589
|
-
const
|
|
1892
|
+
) => {
|
|
1893
|
+
const isKeptLazyExpression = isKeptLazy(expression);
|
|
1590
1894
|
const body = getEvaluator(expression.body, environment);
|
|
1591
1895
|
const bounds = expression.bounds;
|
|
1592
1896
|
const bound = bounds[0];
|
|
1593
1897
|
const isSingleName = bounds.length === 1 && bound.pattern.kind === "Name";
|
|
1594
|
-
const set = getEvaluator(bound.set, environment);
|
|
1595
1898
|
const construct = (domain: Value, context: Context) => {
|
|
1596
1899
|
if (isSingleName && bound.pattern.kind === "Name") {
|
|
1597
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
|
+
}
|
|
1598
1909
|
const keys = getFunctionDomain(domain);
|
|
1599
|
-
const functionValue = createSortedFunction(
|
|
1600
|
-
|
|
1601
|
-
|
|
1602
|
-
);
|
|
1603
|
-
// FcnLambdaValue#toFcnRcd builds a FcnRcdValue over an interval or an enumerated set.
|
|
1604
|
-
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);
|
|
1605
1914
|
}
|
|
1606
1915
|
const pairs: [Value, Value][] = [];
|
|
1607
|
-
const sets = bounds
|
|
1916
|
+
const sets = mapBoundSets(bounds, (set, index) =>
|
|
1608
1917
|
getNormalizedElements(
|
|
1609
|
-
|
|
1610
|
-
|
|
1918
|
+
bounds.length > 1 && typeof domain === "object" && domain.kind === "ProductSet"
|
|
1919
|
+
? domain.factors[index]
|
|
1920
|
+
: domain,
|
|
1921
|
+
set,
|
|
1611
1922
|
context.environment.runtime.version,
|
|
1612
1923
|
),
|
|
1613
1924
|
);
|
|
@@ -1622,15 +1933,26 @@ const compileFunctionConstruction = (
|
|
|
1622
1933
|
return createFunction(pairs);
|
|
1623
1934
|
};
|
|
1624
1935
|
const template = getLazyFunctionTemplate(bounds, expression.body);
|
|
1936
|
+
const boundTupleLengths = getBoundTupleLengths(bounds);
|
|
1625
1937
|
const bodyNames = getScopeNames(expression.body);
|
|
1938
|
+
const coverage = environment.coverage;
|
|
1626
1939
|
const createLazy = (domain: Value, context: Context) => {
|
|
1627
1940
|
const scope = trimScope(context.scope, bodyNames);
|
|
1628
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;
|
|
1629
1945
|
const functionValue = keepLambda({
|
|
1630
1946
|
value: createLazyFunction(
|
|
1631
1947
|
domain,
|
|
1632
|
-
|
|
1948
|
+
coverage
|
|
1949
|
+
? (argument) =>
|
|
1950
|
+
coverage.current === -1
|
|
1951
|
+
? compute(argument)
|
|
1952
|
+
: runAtCoverageNode(coverage, node, () => compute(argument))
|
|
1953
|
+
: compute,
|
|
1633
1954
|
getLazyFunctionSource(template, bounds, domain),
|
|
1955
|
+
boundTupleLengths,
|
|
1634
1956
|
),
|
|
1635
1957
|
bounds,
|
|
1636
1958
|
body: expression.body,
|
|
@@ -1639,15 +1961,22 @@ const compileFunctionConstruction = (
|
|
|
1639
1961
|
return bounds.length === 1 ? markLambdaFunction(functionValue) : functionValue;
|
|
1640
1962
|
};
|
|
1641
1963
|
const callStack = environment.callStack;
|
|
1642
|
-
|
|
1643
|
-
|
|
1644
|
-
|
|
1964
|
+
const build = (domain: Value, context: Context) => {
|
|
1965
|
+
if (
|
|
1966
|
+
expression.isRecursive ||
|
|
1967
|
+
isKeptLazyExpression ||
|
|
1968
|
+
context.isKeepLazy ||
|
|
1969
|
+
!isEnumerable(domain)
|
|
1970
|
+
) {
|
|
1645
1971
|
return createLazy(domain, context);
|
|
1646
1972
|
}
|
|
1647
|
-
|
|
1648
|
-
|
|
1649
|
-
|
|
1650
|
-
|
|
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) {
|
|
1651
1980
|
if (callStack) return createLazy(domain, context);
|
|
1652
1981
|
try {
|
|
1653
1982
|
return construct(domain, context);
|
|
@@ -1657,7 +1986,6 @@ const compileFunctionConstruction = (
|
|
|
1657
1986
|
}
|
|
1658
1987
|
}
|
|
1659
1988
|
if (!callStack) return construct(domain, context);
|
|
1660
|
-
// TLC builds the function in a method of the FcnLambdaValue that CallStackTool gives a source.
|
|
1661
1989
|
try {
|
|
1662
1990
|
return construct(domain, context);
|
|
1663
1991
|
} catch (error) {
|
|
@@ -1665,14 +1993,45 @@ const compileFunctionConstruction = (
|
|
|
1665
1993
|
throw error;
|
|
1666
1994
|
}
|
|
1667
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);
|
|
1668
2027
|
};
|
|
1669
2028
|
|
|
1670
2029
|
const compileExcept = (
|
|
1671
2030
|
expression: Expression & { kind: "Except" },
|
|
1672
2031
|
environment: Environment,
|
|
1673
2032
|
): Evaluator => {
|
|
1674
|
-
const
|
|
1675
|
-
if (
|
|
2033
|
+
const isKeptLazyExpression = keptLazyExpressions.has(expression);
|
|
2034
|
+
if (isKeptLazyExpression) keepLazy(expression.function);
|
|
1676
2035
|
const evaluateFunction = getEvaluator(expression.function, environment);
|
|
1677
2036
|
const updates = expression.updates.map((update) => ({
|
|
1678
2037
|
path: update.path.map((step): CompiledStep =>
|
|
@@ -1705,19 +2064,18 @@ const compileExcept = (
|
|
|
1705
2064
|
current,
|
|
1706
2065
|
getKey(path[depth], context),
|
|
1707
2066
|
(previous) => update(previous, path, depth + 1, context, value),
|
|
1708
|
-
|
|
2067
|
+
isKeptLazyExpression && depth === 0,
|
|
1709
2068
|
);
|
|
1710
2069
|
};
|
|
1711
2070
|
return (context) => {
|
|
1712
2071
|
let current = evaluateFunction(context);
|
|
1713
2072
|
for (const item of updates) {
|
|
1714
|
-
|
|
1715
|
-
const found = { value: false };
|
|
2073
|
+
let isFound = false;
|
|
1716
2074
|
current = update(current, item.path, 0, context, (inner) => {
|
|
1717
|
-
|
|
2075
|
+
isFound = true;
|
|
1718
2076
|
return item.value(inner);
|
|
1719
2077
|
});
|
|
1720
|
-
if (!
|
|
2078
|
+
if (!isFound) {
|
|
1721
2079
|
context.environment.runtime.warn(
|
|
1722
2080
|
MESSAGE_CODE.exceptAppliedToUnknownField,
|
|
1723
2081
|
`The EXCEPT was applied to non-existing fields of the value at\n${describeRange(expression.function)}`,
|
|
@@ -1728,6 +2086,119 @@ const compileExcept = (
|
|
|
1728
2086
|
};
|
|
1729
2087
|
};
|
|
1730
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
|
+
|
|
1731
2202
|
const compileSetComprehension = (
|
|
1732
2203
|
expression: Expression & { kind: "SetFilter" | "SetMap" | "Choose" },
|
|
1733
2204
|
environment: Environment,
|
|
@@ -1735,48 +2206,37 @@ const compileSetComprehension = (
|
|
|
1735
2206
|
if (expression.kind === "SetFilter") {
|
|
1736
2207
|
const predicate = getEvaluator(expression.predicate, environment);
|
|
1737
2208
|
const set = getEvaluator(expression.bound.set, environment);
|
|
2209
|
+
const filterLazily = getLazyFilter(expression, environment);
|
|
1738
2210
|
const pattern = expression.bound.pattern;
|
|
1739
|
-
const
|
|
1740
|
-
const
|
|
1741
|
-
names: pattern.kind === "Name" ? pattern.name : pattern.names.join(", "),
|
|
1742
|
-
predicate: formatRange(range),
|
|
1743
|
-
};
|
|
1744
|
-
const createTest = (evaluator: Evaluator, context: Context) => (element: Value) =>
|
|
1745
|
-
expectBoolean(
|
|
1746
|
-
evaluator(withScope(context, bindPattern(context.scope, pattern, element))),
|
|
1747
|
-
"a set filter predicate",
|
|
1748
|
-
);
|
|
1749
|
-
const createFiltered = (
|
|
1750
|
-
base: Value,
|
|
1751
|
-
context: Context,
|
|
1752
|
-
evaluator: Evaluator,
|
|
1753
|
-
): RebindableFilteredSet => ({
|
|
1754
|
-
kind: "FilteredSet",
|
|
1755
|
-
base,
|
|
1756
|
-
test: createTest(evaluator, context),
|
|
1757
|
-
source,
|
|
1758
|
-
rebind: (tracing) =>
|
|
1759
|
-
createFiltered(
|
|
1760
|
-
base,
|
|
1761
|
-
{ ...context, environment: tracing },
|
|
1762
|
-
getEvaluator(expression.predicate, tracing),
|
|
1763
|
-
),
|
|
1764
|
-
});
|
|
2211
|
+
const coverage = environment.coverage;
|
|
2212
|
+
const isUniform = isUniformPredicate(expression, environment);
|
|
1765
2213
|
return (context) => {
|
|
1766
2214
|
const base = set(context);
|
|
1767
|
-
|
|
1768
|
-
|
|
1769
|
-
|
|
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);
|
|
1770
2227
|
};
|
|
1771
2228
|
}
|
|
1772
2229
|
if (expression.kind === "SetMap") {
|
|
1773
2230
|
const mapped = getEvaluator(expression.expression, environment);
|
|
2231
|
+
const coverage = environment.coverage;
|
|
1774
2232
|
return (context) => {
|
|
1775
2233
|
const elements: Value[] = [];
|
|
1776
|
-
|
|
1777
|
-
elements
|
|
2234
|
+
const add = (scope: Scope | undefined) => {
|
|
2235
|
+
addBoundedElement(elements, mapped(withScope(context, scope)));
|
|
1778
2236
|
return false;
|
|
1779
|
-
}
|
|
2237
|
+
};
|
|
2238
|
+
if (coverage) forEachChargedBinding(expression.bounds, context, coverage, add);
|
|
2239
|
+
else forEachBinding(expression.bounds, context, add);
|
|
1780
2240
|
return createEnumeratedSet(elements);
|
|
1781
2241
|
};
|
|
1782
2242
|
}
|
|
@@ -1784,37 +2244,40 @@ const compileSetComprehension = (
|
|
|
1784
2244
|
if (!set) {
|
|
1785
2245
|
return () => {
|
|
1786
2246
|
throw new TlaEvaluationError(
|
|
1787
|
-
`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)}`,
|
|
1788
2248
|
);
|
|
1789
2249
|
};
|
|
1790
2250
|
}
|
|
1791
2251
|
const body = getEvaluator(expression.body, environment);
|
|
1792
2252
|
const evaluateSet = getEvaluator(set, environment);
|
|
2253
|
+
const coverage = environment.coverage;
|
|
1793
2254
|
return (context) => {
|
|
1794
2255
|
const base = evaluateSet(context);
|
|
1795
|
-
|
|
1796
|
-
|
|
1797
|
-
|
|
1798
|
-
|
|
1799
|
-
}
|
|
1800
|
-
const chosen = { value: undefined as Value | undefined };
|
|
1801
|
-
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;
|
|
1802
2260
|
someElement(elements, (element) => {
|
|
1803
|
-
|
|
1804
|
-
if (
|
|
1805
|
-
|
|
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);
|
|
1806
2273
|
return true;
|
|
1807
2274
|
});
|
|
1808
|
-
if (chosen
|
|
1809
|
-
|
|
1810
|
-
|
|
1811
|
-
);
|
|
1812
|
-
}
|
|
1813
|
-
return chosen.value;
|
|
2275
|
+
if (chosen !== undefined) return chosen;
|
|
2276
|
+
enumerator?.next();
|
|
2277
|
+
throw createNoChoiceError(expression);
|
|
1814
2278
|
};
|
|
1815
2279
|
};
|
|
1816
2280
|
|
|
1817
|
-
// TLC orders a record's fields by name.
|
|
1818
2281
|
export const getSortedFields = (fields: RecordField[]) =>
|
|
1819
2282
|
[...fields].sort((left, right) => compareValues(left.name, right.name));
|
|
1820
2283
|
|
|
@@ -1823,20 +2286,21 @@ export const hasDuplicateFields = (sortedFields: RecordField[]) =>
|
|
|
1823
2286
|
|
|
1824
2287
|
const compileRecord = (recordFields: RecordField[], environment: Environment): Evaluator => {
|
|
1825
2288
|
const fields = getSortedFields(recordFields);
|
|
1826
|
-
const
|
|
1827
|
-
|
|
1828
|
-
if (hasDuplicates) {
|
|
2289
|
+
const values = recordFields.map((field) => getEvaluator(field.value, environment));
|
|
2290
|
+
if (hasDuplicateFields(fields)) {
|
|
1829
2291
|
return (context) =>
|
|
1830
2292
|
createRecord(
|
|
1831
|
-
|
|
2293
|
+
recordFields.map((field, index): [string, Value] => [field.name, values[index](context)]),
|
|
1832
2294
|
);
|
|
1833
2295
|
}
|
|
1834
2296
|
const names = fields.map((field) => field.name);
|
|
1835
2297
|
const writtenNames = recordFields.map((field) => field.name);
|
|
1836
2298
|
if (writtenNames.some((name, index) => name !== names[index])) {
|
|
2299
|
+
const writtenIndexes = fields.map((field) => recordFields.indexOf(field));
|
|
1837
2300
|
return (context) =>
|
|
1838
2301
|
createWrittenRecord(
|
|
1839
2302
|
names,
|
|
2303
|
+
writtenIndexes,
|
|
1840
2304
|
values.map((value) => value(context)),
|
|
1841
2305
|
writtenNames,
|
|
1842
2306
|
);
|
|
@@ -1886,48 +2350,38 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
1886
2350
|
};
|
|
1887
2351
|
case "And": {
|
|
1888
2352
|
const operands = expression.operands.map(getChildEvaluator);
|
|
1889
|
-
return (
|
|
1890
|
-
|
|
1891
|
-
|
|
1892
|
-
|
|
1893
|
-
|
|
1894
|
-
|
|
1895
|
-
|
|
1896
|
-
|
|
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
|
+
);
|
|
1897
2364
|
}
|
|
1898
2365
|
case "Or": {
|
|
1899
2366
|
const operands = expression.operands.map(getChildEvaluator);
|
|
1900
|
-
return (
|
|
1901
|
-
|
|
1902
|
-
|
|
1903
|
-
|
|
1904
|
-
|
|
1905
|
-
|
|
1906
|
-
|
|
1907
|
-
|
|
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
|
+
);
|
|
1908
2378
|
}
|
|
1909
2379
|
case "Prime": {
|
|
1910
2380
|
const inner = getChildEvaluator(expression.expression);
|
|
1911
|
-
return (context) =>
|
|
1912
|
-
if (!context.next) throw createPrimeOutsideActionError(expression);
|
|
1913
|
-
return inner({
|
|
1914
|
-
environment: context.environment,
|
|
1915
|
-
scope: context.scope,
|
|
1916
|
-
state: context.next,
|
|
1917
|
-
next: undefined,
|
|
1918
|
-
isKeepLazy: context.isKeepLazy,
|
|
1919
|
-
});
|
|
1920
|
-
};
|
|
1921
|
-
}
|
|
1922
|
-
case "Unchanged": {
|
|
1923
|
-
const primed = getChildEvaluator({
|
|
1924
|
-
kind: "Prime",
|
|
1925
|
-
expression: expression.expression,
|
|
1926
|
-
location: expression.location,
|
|
1927
|
-
});
|
|
1928
|
-
const current = getChildEvaluator(expression.expression);
|
|
1929
|
-
return (context) => valuesEqual(primed(context), current(context));
|
|
2381
|
+
return (context) => inner(toNextContext(context));
|
|
1930
2382
|
}
|
|
2383
|
+
case "Unchanged":
|
|
2384
|
+
return compileUnchanged(getChildEvaluator(expression.expression));
|
|
1931
2385
|
case "If": {
|
|
1932
2386
|
const condition = getChildEvaluator(expression.condition);
|
|
1933
2387
|
const consequent = getChildEvaluator(expression.consequent);
|
|
@@ -1971,8 +2425,15 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
1971
2425
|
return compileQuantifier(expression, environment);
|
|
1972
2426
|
case "UnboundedQuantifier":
|
|
1973
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
|
+
}
|
|
1974
2435
|
throw new TlaEvaluationError(
|
|
1975
|
-
`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)}`,
|
|
1976
2437
|
);
|
|
1977
2438
|
};
|
|
1978
2439
|
case "Choose":
|
|
@@ -1999,8 +2460,19 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
1999
2460
|
case "RecordSet": {
|
|
2000
2461
|
const fields = getSortedFields(expression.fields);
|
|
2001
2462
|
const names = fields.map((field) => field.name);
|
|
2002
|
-
const
|
|
2003
|
-
|
|
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
|
+
};
|
|
2004
2476
|
}
|
|
2005
2477
|
case "Except":
|
|
2006
2478
|
return compileExcept(expression, environment);
|
|
@@ -2048,16 +2520,18 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2048
2520
|
case "BoxAction":
|
|
2049
2521
|
case "AngleAction": {
|
|
2050
2522
|
const action = getChildEvaluator(expression.action);
|
|
2051
|
-
const unchanged = getChildEvaluator(
|
|
2052
|
-
kind: "Unchanged",
|
|
2053
|
-
expression: expression.subscript,
|
|
2054
|
-
location: expression.location,
|
|
2055
|
-
});
|
|
2523
|
+
const unchanged = compileUnchanged(getChildEvaluator(expression.subscript));
|
|
2056
2524
|
const isBox = expression.kind === "BoxAction";
|
|
2057
|
-
|
|
2058
|
-
|
|
2059
|
-
|
|
2060
|
-
|
|
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
|
+
};
|
|
2061
2535
|
}
|
|
2062
2536
|
case "Enabled": {
|
|
2063
2537
|
const action = expression.expression;
|
|
@@ -2065,6 +2539,8 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2065
2539
|
}
|
|
2066
2540
|
case "Label":
|
|
2067
2541
|
return getChildEvaluator(expression.body);
|
|
2542
|
+
case "Selection":
|
|
2543
|
+
return getChildEvaluator(expression.expression);
|
|
2068
2544
|
case "Subexpression":
|
|
2069
2545
|
return () => {
|
|
2070
2546
|
throw new TlaEvaluationError(
|
|
@@ -2076,9 +2552,7 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2076
2552
|
case "WeakFairness":
|
|
2077
2553
|
case "StrongFairness":
|
|
2078
2554
|
return () => {
|
|
2079
|
-
throw
|
|
2080
|
-
`TLC cannot evaluate a temporal formula in a state at ${describeLocation(expression)}`,
|
|
2081
|
-
);
|
|
2555
|
+
throw createTemporalFormulaError(TEMPORAL_FORMS[expression.kind], expression);
|
|
2082
2556
|
};
|
|
2083
2557
|
}
|
|
2084
2558
|
};
|