tla-ts 0.0.4 → 0.0.5-dev.552d313
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 +38 -127
- package/dist/cli.cjs +1 -1
- package/dist/cli.js +1 -1
- package/dist/deciders.cjs +366 -0
- package/dist/deciders.js +366 -0
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +46 -12
- package/dist/index.d.ts +46 -12
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -4
- package/dist/parallel-worker.js +1 -4
- package/dist/prove-worker.cjs +9 -0
- package/dist/prove-worker.d.cts +9 -0
- package/dist/prove-worker.d.ts +9 -0
- package/dist/prove-worker.js +9 -0
- package/dist/prove.cjs +1006 -0
- package/dist/prove.js +1006 -0
- package/dist/run.cjs +45 -0
- package/dist/run.js +45 -0
- package/dist/tlapm.cjs +10 -0
- package/dist/tlapm.js +10 -0
- package/dist/transfer.cjs +76 -92
- package/dist/transfer.js +76 -92
- package/dist/worker.cjs +21 -0
- package/dist/worker.js +21 -0
- package/package.json +21 -12
- package/src/ast.ts +2 -2
- package/src/bags.ts +22 -23
- package/src/builtins.ts +16 -8
- package/src/check.ts +131 -1153
- package/src/{cli-options.ts → cli/options.ts} +54 -9
- package/src/cli/run.ts +63 -0
- package/src/cli/shared.ts +106 -0
- package/src/cli/tlapm.ts +374 -0
- package/src/{run-cli.ts → cli/tlc.ts} +115 -721
- package/src/cli/xml-exporter.ts +221 -0
- package/src/cli.ts +1 -1
- package/src/codegen.ts +43 -22
- package/src/config.ts +5 -5
- package/src/dependencies.ts +4 -6
- package/src/environment.ts +55 -60
- package/src/errors.ts +97 -35
- package/src/evaluate.ts +361 -181
- package/src/exit-codes.ts +1 -1
- package/src/fingerprints.ts +3 -3
- package/src/index.ts +10 -0
- package/src/instances.ts +56 -46
- package/src/java-overrides.ts +79 -41
- package/src/json.ts +31 -36
- package/src/levels.ts +10 -13
- package/src/{live-check.ts → liveness-checker.ts} +207 -141
- package/src/liveness.ts +38 -34
- package/src/{obligation-action.ts → obligations/action.ts} +248 -74
- package/src/{obligation-anon.ts → obligations/anonymize.ts} +55 -57
- package/src/obligations/equality.ts +260 -0
- package/src/obligations/expression.ts +618 -0
- package/src/{obligation-format.ts → obligations/format.ts} +7 -8
- package/src/obligations/generate.ts +457 -0
- package/src/{obligations.ts → obligations/index.ts} +46 -32
- package/src/{obligation-levels.ts → obligations/levels.ts} +44 -40
- package/src/obligations/module.ts +445 -0
- package/src/obligations/normalize.ts +554 -0
- package/src/obligations/operators.ts +176 -0
- package/src/obligations/pragma.ts +195 -0
- package/src/{obligation-printer.ts → obligations/printer.ts} +65 -230
- package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
- package/src/obligations/regroup.ts +100 -0
- package/src/{obligation-generate.ts → obligations/simplify.ts} +130 -536
- package/src/{obligation-source.ts → obligations/source.ts} +172 -216
- package/src/{obligation-deref.ts → obligations/subexpression.ts} +84 -115
- package/src/obligations/substitution.ts +261 -0
- package/src/obligations/temporal.ts +321 -0
- package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
- package/src/parallel-worker.ts +39 -51
- package/src/parallel.ts +39 -66
- package/src/parser.ts +67 -74
- package/src/{pcal-ast.ts → pcal/ast.ts} +2 -17
- package/src/{pcal-parse.ts → pcal/parse.ts} +28 -64
- package/src/{pcal-tokenize.ts → pcal/tokenize.ts} +10 -39
- package/src/{pcal-translate.ts → pcal/translate.ts} +30 -109
- package/src/{pcal-validate.ts → pcal/validate.ts} +10 -20
- package/src/prover/decide-pool.ts +95 -0
- package/src/prover/deciders.ts +33 -0
- package/src/prover/first-order.ts +175 -0
- package/src/prover/isabelle/LICENSE +36 -0
- package/src/prover/isabelle/LICENSE-tlapm +26 -0
- package/src/prover/isabelle/decide.ts +44 -0
- package/src/prover/isabelle/encode.ts +445 -0
- package/src/prover/isabelle/isar/inner-syntax.ts +579 -0
- package/src/prover/isabelle/isar/method.ts +367 -0
- package/src/prover/isabelle/isar/proof.ts +28 -0
- package/src/prover/isabelle/isar/statement.ts +57 -0
- package/src/prover/isabelle/isar/theory.ts +192 -0
- package/src/prover/isabelle/isar/type-check.ts +278 -0
- package/src/prover/isabelle/provers/blast/blast.ts +258 -0
- package/src/prover/isabelle/provers/blast/branch.ts +322 -0
- package/src/prover/isabelle/provers/blast/prove.ts +347 -0
- package/src/prover/isabelle/provers/blast/rules.ts +330 -0
- package/src/prover/isabelle/provers/blast/state.ts +180 -0
- package/src/prover/isabelle/provers/blast/term.ts +546 -0
- package/src/prover/isabelle/provers/clasimp.ts +150 -0
- package/src/prover/isabelle/provers/classical.ts +389 -0
- package/src/prover/isabelle/provers/hypsubst.ts +433 -0
- package/src/prover/isabelle/pure/bicompose.ts +174 -0
- package/src/prover/isabelle/pure/consts.ts +32 -0
- package/src/prover/isabelle/pure/conv.ts +79 -0
- package/src/prover/isabelle/pure/drule.ts +264 -0
- package/src/prover/isabelle/pure/envir.ts +331 -0
- package/src/prover/isabelle/pure/goal.ts +53 -0
- package/src/prover/isabelle/pure/interrupt.ts +16 -0
- package/src/prover/isabelle/pure/list.ts +12 -0
- package/src/prover/isabelle/pure/logic.ts +330 -0
- package/src/prover/isabelle/pure/name.ts +98 -0
- package/src/prover/isabelle/pure/net.ts +215 -0
- package/src/prover/isabelle/pure/object-logic.ts +41 -0
- package/src/prover/isabelle/pure/pattern.ts +631 -0
- package/src/prover/isabelle/pure/raw-simplifier.ts +338 -0
- package/src/prover/isabelle/pure/rewriter.ts +602 -0
- package/src/prover/isabelle/pure/search.ts +68 -0
- package/src/prover/isabelle/pure/seq.ts +133 -0
- package/src/prover/isabelle/pure/simplifier.ts +106 -0
- package/src/prover/isabelle/pure/table.ts +201 -0
- package/src/prover/isabelle/pure/tactic.ts +168 -0
- package/src/prover/isabelle/pure/tactical.ts +264 -0
- package/src/prover/isabelle/pure/term-ord.ts +105 -0
- package/src/prover/isabelle/pure/term.ts +688 -0
- package/src/prover/isabelle/pure/thm.ts +783 -0
- package/src/prover/isabelle/pure/type.ts +121 -0
- package/src/prover/isabelle/pure/unify.ts +753 -0
- package/src/prover/isabelle/pure/variable.ts +25 -0
- package/src/prover/isabelle/tla/classical-setup.ts +101 -0
- package/src/prover/isabelle/tla/context.ts +74 -0
- package/src/prover/isabelle/tla/logic-data.ts +5 -0
- package/src/prover/isabelle/tla/logic.ts +215 -0
- package/src/prover/isabelle/tla/simpdata.ts +241 -0
- package/src/prover/isabelle/tools/intuitionistic.ts +132 -0
- package/src/prover/ocaml.ts +22 -0
- package/src/prover/prep/action.ts +508 -0
- package/src/prover/prep/enabled-axioms.ts +189 -0
- package/src/prover/prep/fingerprint.ts +388 -0
- package/src/prover/prep/level-comparison.ts +529 -0
- package/src/prover/prep/md5.ts +60 -0
- package/src/prover/prep/methods.ts +221 -0
- package/src/prover/prep/normalize.ts +309 -0
- package/src/prover/prove-worker.ts +22 -0
- package/src/prover/prove.ts +492 -0
- package/src/prover/ptl/decide.ts +68 -0
- package/src/prover/ptl/encode.ts +244 -0
- package/src/prover/ptl/sat.ts +151 -0
- package/src/prover/ptl/tableau.ts +276 -0
- package/src/prover/smt/axioms.ts +209 -0
- package/src/prover/smt/context.ts +108 -0
- package/src/prover/smt/data.ts +636 -0
- package/src/prover/smt/encode.ts +275 -0
- package/src/prover/smt/extensionality.ts +65 -0
- package/src/prover/smt/flatten.ts +112 -0
- package/src/prover/smt/format.ts +154 -0
- package/src/prover/smt/instances.ts +181 -0
- package/src/prover/smt/rewrite.ts +766 -0
- package/src/prover/smt/solver/act-cache.ts +265 -0
- package/src/prover/smt/solver/arith-rewriter.ts +962 -0
- package/src/prover/smt/solver/array.ts +22 -0
- package/src/prover/smt/solver/asserted-formulas.ts +469 -0
- package/src/prover/smt/solver/ast-lt.ts +157 -0
- package/src/prover/smt/solver/ast-util.ts +91 -0
- package/src/prover/smt/solver/ast.ts +1315 -0
- package/src/prover/smt/solver/auf-solver.ts +572 -0
- package/src/prover/smt/solver/case-split-queue.ts +178 -0
- package/src/prover/smt/solver/cg-table.ts +175 -0
- package/src/prover/smt/solver/clause.ts +276 -0
- package/src/prover/smt/solver/conflict-resolution.ts +343 -0
- package/src/prover/smt/solver/context.ts +1292 -0
- package/src/prover/smt/solver/ctx-simplify.ts +334 -0
- package/src/prover/smt/solver/der.ts +224 -0
- package/src/prover/smt/solver/dyn-ack.ts +141 -0
- package/src/prover/smt/solver/e-matching.ts +659 -0
- package/src/prover/smt/solver/enode.ts +259 -0
- package/src/prover/smt/solver/expr-ref.ts +21 -0
- package/src/prover/smt/solver/expr-safe-replace.ts +172 -0
- package/src/prover/smt/solver/fingerprints.ts +92 -0
- package/src/prover/smt/solver/flat-literals.ts +51 -0
- package/src/prover/smt/solver/goal.ts +138 -0
- package/src/prover/smt/solver/hash.ts +173 -0
- package/src/prover/smt/solver/hashtable.ts +166 -0
- package/src/prover/smt/solver/internalizer.ts +1381 -0
- package/src/prover/smt/solver/lbool.ts +5 -0
- package/src/prover/smt/solver/literal.ts +24 -0
- package/src/prover/smt/solver/lp/bound-propagator.ts +391 -0
- package/src/prover/smt/solver/lp/constraints.ts +78 -0
- package/src/prover/smt/solver/lp/containers.ts +296 -0
- package/src/prover/smt/solver/lp/core-solver.ts +504 -0
- package/src/prover/smt/solver/lp/cross-nested.ts +224 -0
- package/src/prover/smt/solver/lp/dep-intervals.ts +642 -0
- package/src/prover/smt/solver/lp/dependency.ts +51 -0
- package/src/prover/smt/solver/lp/dioph-eq.ts +1181 -0
- package/src/prover/smt/solver/lp/explanation.ts +46 -0
- package/src/prover/smt/solver/lp/gomory.ts +255 -0
- package/src/prover/smt/solver/lp/hnf-cutter.ts +125 -0
- package/src/prover/smt/solver/lp/hnf.ts +281 -0
- package/src/prover/smt/solver/lp/int-cube.ts +295 -0
- package/src/prover/smt/solver/lp/int-solver.ts +514 -0
- package/src/prover/smt/solver/lp/lar-solver.ts +816 -0
- package/src/prover/smt/solver/lp/lar-term.ts +62 -0
- package/src/prover/smt/solver/lp/lp-settings.ts +91 -0
- package/src/prover/smt/solver/lp/maximize-term.ts +347 -0
- package/src/prover/smt/solver/lp/nex-creator.ts +381 -0
- package/src/prover/smt/solver/lp/nex.ts +120 -0
- package/src/prover/smt/solver/lp/nla-backoff.ts +43 -0
- package/src/prover/smt/solver/lp/nla-basics.ts +398 -0
- package/src/prover/smt/solver/lp/nla-core.ts +968 -0
- package/src/prover/smt/solver/lp/nla-divisions.ts +332 -0
- package/src/prover/smt/solver/lp/nla-emonics.ts +373 -0
- package/src/prover/smt/solver/lp/nla-factorization.ts +30 -0
- package/src/prover/smt/solver/lp/nla-grobner.ts +904 -0
- package/src/prover/smt/solver/lp/nla-horner.ts +126 -0
- package/src/prover/smt/solver/lp/nla-intervals.ts +265 -0
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +715 -0
- package/src/prover/smt/solver/lp/nla-monotone.ts +59 -0
- package/src/prover/smt/solver/lp/nla-order.ts +307 -0
- package/src/prover/smt/solver/lp/nla-patcher.ts +112 -0
- package/src/prover/smt/solver/lp/nla-tangents.ts +251 -0
- package/src/prover/smt/solver/lp/nla-throttle.ts +85 -0
- package/src/prover/smt/solver/lp/nla-types.ts +124 -0
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +141 -0
- package/src/prover/smt/solver/lp/nra-solver.ts +440 -0
- package/src/prover/smt/solver/lp/numeric-pair.ts +65 -0
- package/src/prover/smt/solver/lp/pdd-interval.ts +31 -0
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +184 -0
- package/src/prover/smt/solver/lp/pdd-solver.ts +408 -0
- package/src/prover/smt/solver/lp/pdd.ts +971 -0
- package/src/prover/smt/solver/lp/random-updater.ts +138 -0
- package/src/prover/smt/solver/lp/static-matrix.ts +246 -0
- package/src/prover/smt/solver/lp/union-find.ts +96 -0
- package/src/prover/smt/solver/mam-compiler.ts +847 -0
- package/src/prover/smt/solver/mam-interpreter.ts +400 -0
- package/src/prover/smt/solver/maximize-ac-sharing.ts +118 -0
- package/src/prover/smt/solver/model-checker.ts +347 -0
- package/src/prover/smt/solver/model-evaluator.ts +262 -0
- package/src/prover/smt/solver/model-finder.ts +155 -0
- package/src/prover/smt/solver/model-generator.ts +97 -0
- package/src/prover/smt/solver/model-macro-solver.ts +728 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +1161 -0
- package/src/prover/smt/solver/nlsat/atoms.ts +238 -0
- package/src/prover/smt/solver/nlsat/evaluator.ts +303 -0
- package/src/prover/smt/solver/nlsat/explain.ts +607 -0
- package/src/prover/smt/solver/nlsat/interval-set.ts +351 -0
- package/src/prover/smt/solver/nlsat/levelwise.ts +737 -0
- package/src/prover/smt/solver/nlsat/mpbq.ts +161 -0
- package/src/prover/smt/solver/nlsat/polynomial.ts +1722 -0
- package/src/prover/smt/solver/nlsat/solver.ts +911 -0
- package/src/prover/smt/solver/nlsat/types.ts +43 -0
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +645 -0
- package/src/prover/smt/solver/nlsat/upolynomial.ts +996 -0
- package/src/prover/smt/solver/nnf.ts +469 -0
- package/src/prover/smt/solver/pattern-inference.ts +351 -0
- package/src/prover/smt/solver/poly-rewriter.ts +477 -0
- package/src/prover/smt/solver/propagate-values.ts +83 -0
- package/src/prover/smt/solver/proto-model.ts +551 -0
- package/src/prover/smt/solver/pull-quant.ts +139 -0
- package/src/prover/smt/solver/qe-lite-der.ts +526 -0
- package/src/prover/smt/solver/qe-lite-fm.ts +576 -0
- package/src/prover/smt/solver/qe-lite.ts +381 -0
- package/src/prover/smt/solver/qi-queue.ts +362 -0
- package/src/prover/smt/solver/quant-tactics.ts +117 -0
- package/src/prover/smt/solver/quantifier-analyzer.ts +562 -0
- package/src/prover/smt/solver/quantifier-manager.ts +186 -0
- package/src/prover/smt/solver/random-gen.ts +10 -0
- package/src/prover/smt/solver/rational.ts +165 -0
- package/src/prover/smt/solver/ref-vector.ts +62 -0
- package/src/prover/smt/solver/relevancy.ts +247 -0
- package/src/prover/smt/solver/rewriter-tpl.ts +1159 -0
- package/src/prover/smt/solver/rewriter.ts +843 -0
- package/src/prover/smt/solver/rlimit.ts +79 -0
- package/src/prover/smt/solver/smtlib-parser.ts +526 -0
- package/src/prover/smt/solver/solver.ts +71 -0
- package/src/prover/smt/solver/sort.ts +35 -0
- package/src/prover/smt/solver/sticky-generations.ts +69 -0
- package/src/prover/smt/solver/theory-lra-axioms.ts +340 -0
- package/src/prover/smt/solver/theory-lra-bounds.ts +226 -0
- package/src/prover/smt/solver/theory-lra-final-check.ts +252 -0
- package/src/prover/smt/solver/theory-lra-internalize.ts +476 -0
- package/src/prover/smt/solver/theory-lra-model.ts +243 -0
- package/src/prover/smt/solver/theory-lra-propagate.ts +405 -0
- package/src/prover/smt/solver/theory-lra-state.ts +43 -0
- package/src/prover/smt/solver/theory-lra.ts +56 -0
- package/src/prover/smt/solver/var-subst.ts +258 -0
- package/src/prover/smt/solver/z3-license.txt +10 -0
- package/src/prover/smt/table.ts +170 -0
- package/src/prover/tlapm/cache.ts +236 -0
- package/src/prover/tlapm/ocaml-marshal.ts +166 -0
- package/src/prover/tlapm/tlapm.ts +96 -0
- package/src/prover/tlaps-module.ts +510 -0
- package/src/prover/verdict.ts +13 -0
- package/src/prover/zenon/LICENSE +32 -0
- package/src/prover/zenon/check/check.ts +105 -0
- package/src/prover/zenon/check/definitions.ts +144 -0
- package/src/prover/zenon/check/equality.ts +182 -0
- package/src/prover/zenon/check/functions.ts +62 -0
- package/src/prover/zenon/check/keys.ts +125 -0
- package/src/prover/zenon/check/propositional.ts +104 -0
- package/src/prover/zenon/check/records.ts +188 -0
- package/src/prover/zenon/check/relations.ts +121 -0
- package/src/prover/zenon/check/rewrites.ts +224 -0
- package/src/prover/zenon/check/sets.ts +302 -0
- package/src/prover/zenon/check/terms.ts +127 -0
- package/src/prover/zenon/check/tla.ts +126 -0
- package/src/prover/zenon/decide.ts +107 -0
- package/src/prover/zenon/encode.ts +378 -0
- package/src/prover/zenon/eqrel.ts +300 -0
- package/src/prover/zenon/equality-rules.ts +435 -0
- package/src/prover/zenon/expr.ts +551 -0
- package/src/prover/zenon/index-table.ts +350 -0
- package/src/prover/zenon/isar-case.ts +513 -0
- package/src/prover/zenon/isar.ts +1249 -0
- package/src/prover/zenon/limits.ts +15 -0
- package/src/prover/zenon/llproof.ts +173 -0
- package/src/prover/zenon/mltoll.ts +1566 -0
- package/src/prover/zenon/node.ts +297 -0
- package/src/prover/zenon/ocaml.ts +169 -0
- package/src/prover/zenon/parse.ts +247 -0
- package/src/prover/zenon/phrase.ts +191 -0
- package/src/prover/zenon/proof.ts +198 -0
- package/src/prover/zenon/propositional-rules.ts +387 -0
- package/src/prover/zenon/rules.ts +94 -0
- package/src/prover/zenon/search.ts +288 -0
- package/src/prover/zenon/tla/functions.ts +151 -0
- package/src/prover/zenon/tla/llproof.ts +480 -0
- package/src/prover/zenon/tla/records.ts +225 -0
- package/src/prover/zenon/tla/rewrites.ts +447 -0
- package/src/prover/zenon/tla/sets.ts +304 -0
- package/src/prover/zenon/tla/terms.ts +162 -0
- package/src/prover/zenon/tla/tla.ts +506 -0
- package/src/randomization.ts +19 -24
- package/src/resolve.ts +15 -22
- package/src/runtime.ts +8 -8
- package/src/{sany-builtins.ts → sany/builtins.ts} +1 -1
- package/src/{sany-generator.ts → sany/generator.ts} +38 -55
- package/src/{sany-levels.ts → sany/levels.ts} +45 -48
- package/src/{sany-lexer.ts → sany/lexer.ts} +2 -3
- package/src/{sany-linter.ts → sany/linter.ts} +1 -1
- package/src/{sany-modules.ts → sany/modules.ts} +2 -2
- package/src/{sany-nodes.ts → sany/nodes.ts} +2 -2
- package/src/{sany-parse-error.ts → sany/parse-error.ts} +2 -2
- package/src/{sany-report.ts → sany/report.ts} +16 -17
- package/src/{sany-selectors.ts → sany/selectors.ts} +3 -5
- package/src/{sany-source.ts → sany/source.ts} +6 -7
- package/src/{sany-xml.ts → sany/xml.ts} +5 -6
- package/src/search.ts +969 -0
- package/src/spec-description.ts +26 -20
- package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
- package/src/standard-modules.ts +21 -22
- package/src/state-graph.ts +9 -8
- package/src/substitution-levels.ts +2 -2
- package/src/successors.ts +39 -23
- package/src/symmetry.ts +1 -1
- package/src/tableau.ts +6 -7
- package/src/tlc/fingerprint.ts +214 -0
- package/src/{tlc-messages.ts → tlc/messages.ts} +119 -7
- package/src/{tlc-order.ts → tlc/order.ts} +7 -7
- package/src/{tlc-random.ts → tlc/random.ts} +3 -190
- package/src/{tlc-replay.ts → tlc/replay.ts} +40 -36
- package/src/{tlc-module.ts → tlc/tlc-operators.ts} +9 -9
- package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +30 -25
- package/src/{tlc-version.ts → tlc/version.ts} +8 -7
- package/src/transfer.ts +32 -32
- package/src/values.ts +166 -111
- package/src/worker.ts +62 -0
- package/dist/parallel.cjs +0 -12
- package/dist/parallel.js +0 -12
- package/dist/run-cli.cjs +0 -55
- package/dist/run-cli.js +0 -55
- package/src/canonical.ts +0 -40
- package/src/obligation-expression.ts +0 -1060
- package/src/obligation-module.ts +0 -1042
- package/src/standard-ranges.ts +0 -116
- package/src/value-sources.ts +0 -29
- /package/src/{tlc-modules.ts → tlc/jar-data.ts} +0 -0
- /package/src/{tlc-summary.ts → tlc/summary.ts} +0 -0
package/src/evaluate.ts
CHANGED
|
@@ -16,12 +16,12 @@ import { getKindString } from "./builtins";
|
|
|
16
16
|
import { isStackOverflow, TlaEvaluationError, TlaUnassignedError } from "./errors";
|
|
17
17
|
import { EXIT_STATUS, setExitCode } from "./exit-codes";
|
|
18
18
|
import { generateEvaluator } from "./codegen";
|
|
19
|
-
import { MESSAGE_CODE } from "./tlc
|
|
19
|
+
import { MESSAGE_CODE } from "./tlc/messages";
|
|
20
20
|
import type { CheckerRuntime } from "./runtime";
|
|
21
21
|
import { getReadVariables } from "./dependencies";
|
|
22
22
|
import { contextualApplications, mapChildren, substitutedExpressions } from "./instances";
|
|
23
23
|
import { prettyPrint } from "./pretty-print";
|
|
24
|
-
import { isEnabled } from "./successors";
|
|
24
|
+
import { getReadLocals, isEnabled } from "./successors";
|
|
25
25
|
import {
|
|
26
26
|
applyFunction,
|
|
27
27
|
describeMissingArgument,
|
|
@@ -54,8 +54,8 @@ import {
|
|
|
54
54
|
markLambdaFunction,
|
|
55
55
|
isReducibleSet,
|
|
56
56
|
isSetValue,
|
|
57
|
-
|
|
58
|
-
|
|
57
|
+
isSettledValue,
|
|
58
|
+
isTlcInteger,
|
|
59
59
|
toFiniteFunction,
|
|
60
60
|
toFiniteSet,
|
|
61
61
|
updateFunction,
|
|
@@ -68,7 +68,7 @@ import {
|
|
|
68
68
|
markNormalized,
|
|
69
69
|
setTrace,
|
|
70
70
|
} from "./values";
|
|
71
|
-
import type { TlcVersion } from "./tlc
|
|
71
|
+
import type { TlcVersion } from "./tlc/version";
|
|
72
72
|
|
|
73
73
|
export type State = (Value | undefined)[];
|
|
74
74
|
|
|
@@ -113,6 +113,9 @@ export interface Thunk {
|
|
|
113
113
|
state: State | undefined;
|
|
114
114
|
next: State | undefined;
|
|
115
115
|
cache: Value | undefined;
|
|
116
|
+
// Whether the expression may build a set that streams until TLC caches it, so that the thunk
|
|
117
|
+
// caches only a settled value.
|
|
118
|
+
isStreamed: boolean;
|
|
116
119
|
}
|
|
117
120
|
|
|
118
121
|
type Binding = { kind: "Value"; value: Value } | Thunk | { kind: "Operator"; operator: Operator };
|
|
@@ -248,14 +251,14 @@ export const describeNode = (expression: Expression) =>
|
|
|
248
251
|
? (expression.text ?? String(expression.value))
|
|
249
252
|
: describeRange(expression);
|
|
250
253
|
|
|
251
|
-
export const
|
|
254
|
+
export const createConditionError = (expression: Expression, value: Value) =>
|
|
252
255
|
new TlaEvaluationError(
|
|
253
256
|
`A non-boolean expression (${getKindString(value)}) was used as the condition of an IF.\n${describeRange(expression)}`,
|
|
254
257
|
);
|
|
255
258
|
|
|
256
259
|
// TLC parses an infix chain of /\ or \/ as nested binary junctions and a bulleted list as one
|
|
257
260
|
// junction list, and it words the error differently for each.
|
|
258
|
-
export const
|
|
261
|
+
export const createJunctionError = (
|
|
259
262
|
expression: Expression & { kind: "And" | "Or" },
|
|
260
263
|
index: number,
|
|
261
264
|
value: Value,
|
|
@@ -344,6 +347,27 @@ export const createBigNumberError = (expression: NumberExpression) =>
|
|
|
344
347
|
EXIT_STATUS.error,
|
|
345
348
|
);
|
|
346
349
|
|
|
350
|
+
// TLC's Tool#evalAppl fails to look up a variable the state doesn't assign.
|
|
351
|
+
export const createUnassignedError = (name: string, expression: Expression) =>
|
|
352
|
+
new TlaUnassignedError(
|
|
353
|
+
`In evaluation, the identifier ${name} is either undefined or not an operator.\n${describeRange(expression)}`,
|
|
354
|
+
name,
|
|
355
|
+
);
|
|
356
|
+
|
|
357
|
+
// TLC's Tool#enabled reads the subscript of <<A>>_v in the successor as a state of its own, and
|
|
358
|
+
// names the fairness condition when A leaves a variable of v unassigned, unlike TLC 1.7.4's.
|
|
359
|
+
export const toUnspecifiedSubscriptError = (error: unknown, version: TlcVersion | undefined) =>
|
|
360
|
+
error instanceof TlaUnassignedError && version !== "1.7.4"
|
|
361
|
+
? new TlaEvaluationError(
|
|
362
|
+
`The action formula A appearing in a WF_v(A) or SF_v(A) operator does not specify the primed value of the variable ${error.variable} occurring in the state formula v.\n`,
|
|
363
|
+
)
|
|
364
|
+
: error;
|
|
365
|
+
|
|
366
|
+
export const createPrimeOutsideActionError = (expression: Expression) =>
|
|
367
|
+
new TlaEvaluationError(
|
|
368
|
+
`A primed expression appears outside an action at ${describeLocation(expression)}`,
|
|
369
|
+
);
|
|
370
|
+
|
|
347
371
|
export const lookupScope = (scope: Scope | undefined, name: string): Binding | undefined => {
|
|
348
372
|
for (let current = scope; current; current = current.parent) {
|
|
349
373
|
if (current.name === name) return current.binding;
|
|
@@ -380,7 +404,15 @@ export const expectFunction = (value: Value, application: Expression) => {
|
|
|
380
404
|
};
|
|
381
405
|
|
|
382
406
|
export const toKeepLazyContext = (context: Context): Context =>
|
|
383
|
-
context.isKeepLazy
|
|
407
|
+
context.isKeepLazy
|
|
408
|
+
? context
|
|
409
|
+
: {
|
|
410
|
+
environment: context.environment,
|
|
411
|
+
scope: context.scope,
|
|
412
|
+
state: context.state,
|
|
413
|
+
next: context.next,
|
|
414
|
+
isKeepLazy: true,
|
|
415
|
+
};
|
|
384
416
|
|
|
385
417
|
const withScope = (context: Context, scope: Scope | undefined): Context => ({
|
|
386
418
|
environment: context.environment,
|
|
@@ -555,12 +587,12 @@ export const forEachBinding = (
|
|
|
555
587
|
visit: (scope: Scope | undefined) => boolean,
|
|
556
588
|
) => forEachBoundElement(bounds, getBoundElements(bounds, context), context.scope, visit);
|
|
557
589
|
|
|
558
|
-
|
|
590
|
+
const getBoundsDomain = (bounds: Bound[], context: Context): Value => {
|
|
559
591
|
const sets = bounds.map((bound) => evaluate(bound.set, context));
|
|
560
592
|
return sets.length === 1 ? sets[0] : { kind: "ProductSet", factors: sets };
|
|
561
593
|
};
|
|
562
594
|
|
|
563
|
-
|
|
595
|
+
const bindArgument = (bounds: Bound[], scope: Scope | undefined, argument: Value) => {
|
|
564
596
|
if (bounds.length === 1) return bindPattern(scope, bounds[0].pattern, argument);
|
|
565
597
|
const components = getSequenceElements(argument) ?? [];
|
|
566
598
|
return bounds.reduce<Scope | undefined>(
|
|
@@ -578,15 +610,19 @@ interface LazyFunction {
|
|
|
578
610
|
scope: Scope | undefined;
|
|
579
611
|
}
|
|
580
612
|
|
|
581
|
-
|
|
613
|
+
// The function keeps its parameters, body and scope itself, since a WeakMap entry for each
|
|
614
|
+
// short-lived function makes every garbage collection slower.
|
|
615
|
+
interface KeptLazyFunctionValue extends LazyFunctionValue {
|
|
616
|
+
lambda: LazyFunction;
|
|
617
|
+
}
|
|
582
618
|
|
|
583
|
-
const
|
|
584
|
-
|
|
585
|
-
|
|
586
|
-
};
|
|
619
|
+
const isKeptLazyFunction = (value: Value): value is KeptLazyFunctionValue =>
|
|
620
|
+
typeof value === "object" && value.kind === "LazyFunction" && "lambda" in value;
|
|
621
|
+
|
|
622
|
+
const keepLambda = (lambda: LazyFunction) => Object.assign(lambda.value, { lambda });
|
|
587
623
|
|
|
588
624
|
export const getLazyFunction = (value: Value) =>
|
|
589
|
-
|
|
625
|
+
isKeptLazyFunction(value) ? value.lambda : undefined;
|
|
590
626
|
|
|
591
627
|
// Tool.getFcnContext: the scope of a lazy function's body for the arguments of an application. It
|
|
592
628
|
// ignores arguments beyond the parameters.
|
|
@@ -835,7 +871,7 @@ const forceThunk = (thunk: Thunk, context: Context) => {
|
|
|
835
871
|
const isSameState = thunk.state === context.state && thunk.next === context.next;
|
|
836
872
|
if (isSameState && thunk.cache !== undefined) return thunk.cache;
|
|
837
873
|
const value = evaluate(thunk.expression, withScope(context, thunk.scope));
|
|
838
|
-
if (isSameState) thunk.cache = value;
|
|
874
|
+
if (isSameState && (!thunk.isStreamed || isSettledValue(value))) thunk.cache = value;
|
|
839
875
|
return value;
|
|
840
876
|
};
|
|
841
877
|
|
|
@@ -949,6 +985,18 @@ const isOperatorArgument = (expression: Expression, context: Context) => {
|
|
|
949
985
|
return operator !== undefined && getArity(operator) > 0;
|
|
950
986
|
};
|
|
951
987
|
|
|
988
|
+
const evaluateBuiltinArguments = (args: Expression[], context: Context) =>
|
|
989
|
+
args.map((arg) =>
|
|
990
|
+
isOperatorArgument(arg, context)
|
|
991
|
+
? toOperatorValue(evaluateOperatorArgument(arg, context), context)
|
|
992
|
+
: evaluate(arg, context),
|
|
993
|
+
);
|
|
994
|
+
|
|
995
|
+
const createArityError = (closure: Closure, count: number) =>
|
|
996
|
+
new TlaEvaluationError(
|
|
997
|
+
`Operator ${closure.name} expects ${closure.params.length} arguments but received ${count}`,
|
|
998
|
+
);
|
|
999
|
+
|
|
952
1000
|
const createThunk = (expression: Expression, context: Context): Thunk => ({
|
|
953
1001
|
kind: "Thunk",
|
|
954
1002
|
expression,
|
|
@@ -956,6 +1004,7 @@ const createThunk = (expression: Expression, context: Context): Thunk => ({
|
|
|
956
1004
|
state: context.state,
|
|
957
1005
|
next: context.next,
|
|
958
1006
|
cache: undefined,
|
|
1007
|
+
isStreamed: false,
|
|
959
1008
|
});
|
|
960
1009
|
|
|
961
1010
|
export const findGlobalName = (name: string, environment: Environment): GlobalName | undefined => {
|
|
@@ -1015,47 +1064,61 @@ export const bindOperatorArguments = (
|
|
|
1015
1064
|
closure: Closure,
|
|
1016
1065
|
args: Expression[],
|
|
1017
1066
|
context: Context,
|
|
1067
|
+
binders?: ArgumentBinder[],
|
|
1018
1068
|
): Scope | undefined => {
|
|
1019
|
-
if (args.length !== closure.params.length)
|
|
1020
|
-
throw new TlaEvaluationError(
|
|
1021
|
-
`Operator ${closure.name} expects ${closure.params.length} arguments but received ${args.length}`,
|
|
1022
|
-
);
|
|
1023
|
-
}
|
|
1069
|
+
if (args.length !== closure.params.length) throw createArityError(closure, args.length);
|
|
1024
1070
|
let scope = closure.scope;
|
|
1025
1071
|
for (let index = 0; index < args.length; index++) {
|
|
1026
1072
|
const param = closure.params[index];
|
|
1027
1073
|
const binding: Binding =
|
|
1028
1074
|
param.arity > 0
|
|
1029
1075
|
? { kind: "Operator", operator: evaluateOperatorArgument(args[index], context) }
|
|
1030
|
-
: getArgumentBinder(args[index], context.environment)(context);
|
|
1076
|
+
: (binders?.[index] ?? getArgumentBinder(args[index], context.environment))(context);
|
|
1031
1077
|
scope = { name: param.name, binding, parent: scope };
|
|
1032
1078
|
}
|
|
1033
1079
|
return scope;
|
|
1034
1080
|
};
|
|
1035
1081
|
|
|
1036
|
-
|
|
1082
|
+
// The body a call site last called and its evaluator, as a site mostly calls one closure.
|
|
1083
|
+
interface CalledBody {
|
|
1084
|
+
body: Expression;
|
|
1085
|
+
evaluator: Evaluator;
|
|
1086
|
+
}
|
|
1087
|
+
|
|
1088
|
+
const callOperator = (
|
|
1089
|
+
operator: Operator,
|
|
1090
|
+
args: Expression[],
|
|
1091
|
+
context: Context,
|
|
1092
|
+
called: { entry: CalledBody | undefined },
|
|
1093
|
+
binders: ArgumentBinder[],
|
|
1094
|
+
) => {
|
|
1037
1095
|
if (operator.kind === "Closure") {
|
|
1038
|
-
|
|
1039
|
-
|
|
1040
|
-
|
|
1041
|
-
|
|
1096
|
+
const bodyContext = withScope(context, bindOperatorArguments(operator, args, context, binders));
|
|
1097
|
+
if (context.environment.callStack) return evaluate(operator.body, bodyContext);
|
|
1098
|
+
const entry =
|
|
1099
|
+
called.entry?.body === operator.body
|
|
1100
|
+
? called.entry
|
|
1101
|
+
: (called.entry = {
|
|
1102
|
+
body: operator.body,
|
|
1103
|
+
evaluator: getEntryEvaluator(operator.body, context.environment),
|
|
1104
|
+
});
|
|
1105
|
+
return entry.evaluator(bodyContext);
|
|
1042
1106
|
}
|
|
1043
1107
|
if (operator.kind === "Operator") return operator.call(args.map((arg) => evaluate(arg, context)));
|
|
1044
1108
|
if (operator.isLazy) return operator.evaluate(getLazyArguments(args, context), context);
|
|
1045
|
-
return operator.evaluate(
|
|
1046
|
-
args.map((arg) =>
|
|
1047
|
-
isOperatorArgument(arg, context)
|
|
1048
|
-
? toOperatorValue(evaluateOperatorArgument(arg, context), context)
|
|
1049
|
-
: evaluate(arg, context),
|
|
1050
|
-
),
|
|
1051
|
-
context,
|
|
1052
|
-
);
|
|
1109
|
+
return operator.evaluate(evaluateBuiltinArguments(args, context), context);
|
|
1053
1110
|
};
|
|
1054
1111
|
|
|
1112
|
+
// The LET definitions that a reference evaluates again, and those that cache only a settled value.
|
|
1113
|
+
interface ReevaluatedDefinitions {
|
|
1114
|
+
impure: ReadonlySet<Definition>;
|
|
1115
|
+
streamed: ReadonlySet<Definition>;
|
|
1116
|
+
}
|
|
1117
|
+
|
|
1055
1118
|
export const bindDefinitions = (
|
|
1056
1119
|
definitions: Definition[],
|
|
1057
1120
|
context: Context,
|
|
1058
|
-
reevaluated?:
|
|
1121
|
+
reevaluated?: ReevaluatedDefinitions,
|
|
1059
1122
|
): Scope | undefined =>
|
|
1060
1123
|
definitions.reduce<Scope | undefined>((scope, definition) => {
|
|
1061
1124
|
const node: Scope = {
|
|
@@ -1077,10 +1140,11 @@ export const bindDefinitions = (
|
|
|
1077
1140
|
state: context.state,
|
|
1078
1141
|
next: context.next,
|
|
1079
1142
|
cache: undefined,
|
|
1143
|
+
isStreamed: false,
|
|
1080
1144
|
};
|
|
1081
1145
|
return node;
|
|
1082
1146
|
}
|
|
1083
|
-
if (definition.params.length > 0 || reevaluated?.has(definition)) {
|
|
1147
|
+
if (definition.params.length > 0 || reevaluated?.impure.has(definition)) {
|
|
1084
1148
|
node.binding = {
|
|
1085
1149
|
kind: "Operator",
|
|
1086
1150
|
operator: {
|
|
@@ -1100,6 +1164,7 @@ export const bindDefinitions = (
|
|
|
1100
1164
|
state: context.state,
|
|
1101
1165
|
next: context.next,
|
|
1102
1166
|
cache: undefined,
|
|
1167
|
+
isStreamed: reevaluated?.streamed.has(definition) ?? false,
|
|
1103
1168
|
};
|
|
1104
1169
|
return node;
|
|
1105
1170
|
}, context.scope);
|
|
@@ -1127,9 +1192,6 @@ const evaluateLocalIdentifier = (name: string, expression: Expression, context:
|
|
|
1127
1192
|
throw new TlaEvaluationError(`Unknown identifier ${name} at ${describeLocation(expression)}`);
|
|
1128
1193
|
};
|
|
1129
1194
|
|
|
1130
|
-
export const isTlcInteger = (value: number) =>
|
|
1131
|
-
Number.isInteger(value) && value <= MAXIMUM_INTEGER && value >= MINIMUM_INTEGER;
|
|
1132
|
-
|
|
1133
1195
|
const IMPURE_BUILTINS = new Set([
|
|
1134
1196
|
"Print",
|
|
1135
1197
|
"PrintT",
|
|
@@ -1216,14 +1278,15 @@ const STREAMED_SET: Impurity = {
|
|
|
1216
1278
|
// TLC's next-state generator does not bind LET definitions to values, so each reference to one
|
|
1217
1279
|
// evaluates it again: one that calls an impure builtin repeats its effects, and a set one builds
|
|
1218
1280
|
// with UNION or \cup starts out uncached.
|
|
1219
|
-
export const getReevaluatedDefinitions = (
|
|
1220
|
-
|
|
1221
|
-
|
|
1222
|
-
|
|
1223
|
-
|
|
1224
|
-
|
|
1225
|
-
),
|
|
1226
|
-
)
|
|
1281
|
+
export const getReevaluatedDefinitions = (
|
|
1282
|
+
definitions: Definition[],
|
|
1283
|
+
environment: Environment,
|
|
1284
|
+
): ReevaluatedDefinitions => ({
|
|
1285
|
+
impure: new Set(definitions.filter((definition) => isImpureDefinition(definition, environment))),
|
|
1286
|
+
streamed: new Set(
|
|
1287
|
+
definitions.filter((definition) => isImpureDefinition(definition, environment, STREAMED_SET)),
|
|
1288
|
+
),
|
|
1289
|
+
});
|
|
1227
1290
|
|
|
1228
1291
|
export const isImpure = (environment: Environment) =>
|
|
1229
1292
|
[...environment.definitions.values()].some((definition) =>
|
|
@@ -1375,9 +1438,14 @@ const isStateCached = (expression: Expression, environment: Environment) =>
|
|
|
1375
1438
|
getReadVariables(expression, environment) !== undefined &&
|
|
1376
1439
|
!hasFreeLocals(expression, NO_BOUND_NAMES);
|
|
1377
1440
|
|
|
1378
|
-
//
|
|
1441
|
+
// A set filter TLC evaluates lazily, with how to rebuild it so that its predicate runs in another
|
|
1379
1442
|
// environment.
|
|
1380
|
-
|
|
1443
|
+
interface RebindableFilteredSet extends FilteredSetValue {
|
|
1444
|
+
rebind: (environment: Environment) => Value;
|
|
1445
|
+
}
|
|
1446
|
+
|
|
1447
|
+
const isRebindableFilteredSet = (value: Value): value is RebindableFilteredSet =>
|
|
1448
|
+
typeof value === "object" && value.kind === "FilteredSet" && "rebind" in value;
|
|
1381
1449
|
|
|
1382
1450
|
// TLC's CallStackTool rebinds the lazy values its evaluations return, so their later evaluation
|
|
1383
1451
|
// records its call stack too.
|
|
@@ -1398,11 +1466,7 @@ const traceEvaluator =
|
|
|
1398
1466
|
setTrace.callStack = callStack;
|
|
1399
1467
|
try {
|
|
1400
1468
|
const computed = evaluator(context);
|
|
1401
|
-
const rebind
|
|
1402
|
-
typeof computed === "object" && computed.kind === "FilteredSet"
|
|
1403
|
-
? filteredSetRebinders.get(computed)
|
|
1404
|
-
: undefined;
|
|
1405
|
-
const value = rebind ? rebind(environment) : computed;
|
|
1469
|
+
const value = isRebindableFilteredSet(computed) ? computed.rebind(environment) : computed;
|
|
1406
1470
|
callStack.values.set(expression, value);
|
|
1407
1471
|
if (typeof value === "object" && value.kind !== "FilteredSet" && isSourced(expression)) {
|
|
1408
1472
|
callStack.sources.set(value, expression);
|
|
@@ -1506,7 +1570,7 @@ export const getEvaluator = (expression: Expression, environment: Environment):
|
|
|
1506
1570
|
|
|
1507
1571
|
const entryEvaluators = new WeakMap<Expression, Evaluator>();
|
|
1508
1572
|
|
|
1509
|
-
const getEntryEvaluator = (expression: Expression, environment: Environment) => {
|
|
1573
|
+
export const getEntryEvaluator = (expression: Expression, environment: Environment) => {
|
|
1510
1574
|
if (environment.callStack) return getEvaluator(expression, environment);
|
|
1511
1575
|
const cached = entryEvaluators.get(expression);
|
|
1512
1576
|
if (cached) return cached;
|
|
@@ -1593,20 +1657,13 @@ const cacheStateValue = (evaluator: Evaluator): Evaluator => {
|
|
|
1593
1657
|
};
|
|
1594
1658
|
};
|
|
1595
1659
|
|
|
1596
|
-
const
|
|
1597
|
-
|
|
1598
|
-
|
|
1660
|
+
export const isValueArgument = (argument: Expression, environment: Environment) => {
|
|
1661
|
+
if (argument.kind === "Lambda" || argument.kind === "OperatorReference") return false;
|
|
1662
|
+
if (argument.kind !== "Identifier" || isLocallyResolved(argument)) return true;
|
|
1663
|
+
const operator = resolveGlobalOperator(argument.name, environment);
|
|
1664
|
+
return operator === undefined || getArity(operator) === 0;
|
|
1599
1665
|
};
|
|
1600
1666
|
|
|
1601
|
-
export const isValueArgument = (argument: Expression, environment: Environment) =>
|
|
1602
|
-
argument.kind !== "Lambda" &&
|
|
1603
|
-
argument.kind !== "OperatorReference" &&
|
|
1604
|
-
!(
|
|
1605
|
-
argument.kind === "Identifier" &&
|
|
1606
|
-
!isLocallyResolved(argument) &&
|
|
1607
|
-
isOperatorName(argument.name, environment)
|
|
1608
|
-
);
|
|
1609
|
-
|
|
1610
1667
|
const getLazyArguments = (args: Expression[], context: Context): OperatorValue[] =>
|
|
1611
1668
|
args.map((arg) => ({
|
|
1612
1669
|
kind: "Operator",
|
|
@@ -1639,15 +1696,7 @@ const compileBuiltinCall = (
|
|
|
1639
1696
|
const right = getEvaluator(args[1], environment);
|
|
1640
1697
|
return (context) => binary(left(context), right(context));
|
|
1641
1698
|
}
|
|
1642
|
-
return (context) =>
|
|
1643
|
-
builtin.evaluate(
|
|
1644
|
-
args.map((arg) =>
|
|
1645
|
-
isOperatorArgument(arg, context)
|
|
1646
|
-
? toOperatorValue(evaluateOperatorArgument(arg, context), context)
|
|
1647
|
-
: evaluate(arg, context),
|
|
1648
|
-
),
|
|
1649
|
-
context,
|
|
1650
|
-
);
|
|
1699
|
+
return (context) => builtin.evaluate(evaluateBuiltinArguments(args, context), context);
|
|
1651
1700
|
};
|
|
1652
1701
|
|
|
1653
1702
|
export const compileArgumentScope = (
|
|
@@ -1657,9 +1706,7 @@ export const compileArgumentScope = (
|
|
|
1657
1706
|
): ((context: Context) => Scope | undefined) => {
|
|
1658
1707
|
if (args.length !== closure.params.length) {
|
|
1659
1708
|
return () => {
|
|
1660
|
-
throw
|
|
1661
|
-
`Operator ${closure.name} expects ${closure.params.length} arguments but received ${args.length}`,
|
|
1662
|
-
);
|
|
1709
|
+
throw createArityError(closure, args.length);
|
|
1663
1710
|
};
|
|
1664
1711
|
}
|
|
1665
1712
|
const params = closure.params;
|
|
@@ -1680,52 +1727,180 @@ export const compileArgumentScope = (
|
|
|
1680
1727
|
};
|
|
1681
1728
|
|
|
1682
1729
|
interface MemoizedCall {
|
|
1730
|
+
sources: (Expression | undefined)[];
|
|
1683
1731
|
args: Value[];
|
|
1684
1732
|
value: Value;
|
|
1685
1733
|
}
|
|
1686
1734
|
|
|
1687
1735
|
const MEMOIZED_CALL_LIMIT = 1 << 16;
|
|
1688
1736
|
|
|
1689
|
-
|
|
1737
|
+
// A call site that finds fewer than half its calls in a state's memo after this many new ones
|
|
1738
|
+
// stops paying for the lookups.
|
|
1739
|
+
const MEMOIZED_TRIAL_CALLS = 1 << 10;
|
|
1740
|
+
|
|
1741
|
+
interface CallMemo {
|
|
1742
|
+
calls: Map<number, MemoizedCall[]>;
|
|
1743
|
+
size: number;
|
|
1744
|
+
state: Context["state"];
|
|
1745
|
+
}
|
|
1746
|
+
|
|
1747
|
+
interface CallMemos {
|
|
1748
|
+
constant: CallMemo;
|
|
1749
|
+
state: CallMemo;
|
|
1750
|
+
}
|
|
1751
|
+
|
|
1752
|
+
const createCallMemo = (): CallMemo => ({ calls: new Map(), size: 0, state: undefined });
|
|
1753
|
+
|
|
1754
|
+
const callMemos = new WeakMap<Closure, CallMemos>();
|
|
1690
1755
|
|
|
1691
|
-
const
|
|
1756
|
+
const getCallMemos = (closure: Closure) => {
|
|
1692
1757
|
const cached = callMemos.get(closure);
|
|
1693
1758
|
if (cached) return cached;
|
|
1694
|
-
const
|
|
1695
|
-
callMemos.set(closure,
|
|
1696
|
-
return
|
|
1759
|
+
const memos = { constant: createCallMemo(), state: createCallMemo() };
|
|
1760
|
+
callMemos.set(closure, memos);
|
|
1761
|
+
return memos;
|
|
1697
1762
|
};
|
|
1698
1763
|
|
|
1699
|
-
const
|
|
1700
|
-
|
|
1701
|
-
|
|
1702
|
-
|
|
1703
|
-
|
|
1764
|
+
const readsExceptAt = (expression: Expression): boolean =>
|
|
1765
|
+
expression.kind === "ExceptAt" || getChildren(expression).some(readsExceptAt);
|
|
1766
|
+
|
|
1767
|
+
// The locals an argument expression reads, when the state and their values decide its value. An @
|
|
1768
|
+
// reads the value its EXCEPT binds.
|
|
1769
|
+
const argumentLocals = new WeakMap<Expression, string[] | false>();
|
|
1770
|
+
|
|
1771
|
+
const getArgumentLocals = (expression: Expression, environment: Environment) => {
|
|
1772
|
+
const cached = argumentLocals.get(expression);
|
|
1773
|
+
if (cached !== undefined) return cached;
|
|
1774
|
+
const locals =
|
|
1775
|
+
getReadVariables(expression, environment) !== undefined &&
|
|
1776
|
+
getReadLocals(expression, NO_BOUND_NAMES);
|
|
1777
|
+
const unique = locals && [
|
|
1778
|
+
...new Set(readsExceptAt(expression) ? [...locals, EXCEPT_AT] : locals),
|
|
1779
|
+
];
|
|
1780
|
+
argumentLocals.set(expression, unique ?? false);
|
|
1781
|
+
return unique ?? false;
|
|
1782
|
+
};
|
|
1783
|
+
|
|
1784
|
+
// Hashing a lazy set or function would enumerate it, which TLC does only when it has to.
|
|
1785
|
+
const isEagerValue = (value: Value) =>
|
|
1786
|
+
typeof value !== "object" ||
|
|
1787
|
+
value.kind === "ModelValue" ||
|
|
1788
|
+
value.kind === "Set" ||
|
|
1789
|
+
value.kind === "Function" ||
|
|
1790
|
+
value.kind === "Interval";
|
|
1791
|
+
|
|
1792
|
+
// The key of the call being looked up, copied into the memo only when the call is new. Counts
|
|
1793
|
+
// mark its ends, since shortening an array is slow.
|
|
1794
|
+
const callKey = {
|
|
1795
|
+
sources: [] as (Expression | undefined)[],
|
|
1796
|
+
sourceCount: 0,
|
|
1797
|
+
args: [] as Value[],
|
|
1798
|
+
argCount: 0,
|
|
1799
|
+
hash: 0,
|
|
1800
|
+
isStateKeyed: false,
|
|
1801
|
+
};
|
|
1802
|
+
|
|
1803
|
+
// A model value's rank tells it apart without hashing its name.
|
|
1804
|
+
const getKeyHash = (value: Value) =>
|
|
1805
|
+
typeof value === "object" && value.kind === "ModelValue" ? value.rank : getValueHash(value);
|
|
1806
|
+
|
|
1807
|
+
const pushKeyValue = (value: Value) => {
|
|
1808
|
+
if (!isEagerValue(value)) return false;
|
|
1809
|
+
callKey.sources[callKey.sourceCount++] = undefined;
|
|
1810
|
+
callKey.args[callKey.argCount++] = value;
|
|
1811
|
+
callKey.hash = combineHash(callKey.hash, getKeyHash(value));
|
|
1812
|
+
return true;
|
|
1813
|
+
};
|
|
1814
|
+
|
|
1815
|
+
// An argument TLC has not evaluated yet stands for its expression and the values of the locals it
|
|
1816
|
+
// reads, so a call keeps the laziness of its arguments.
|
|
1817
|
+
const pushKeyExpression = (
|
|
1818
|
+
expression: Expression,
|
|
1819
|
+
locals: string[] | false,
|
|
1820
|
+
scope: Scope | undefined,
|
|
1821
|
+
) => {
|
|
1822
|
+
if (!locals) return false;
|
|
1823
|
+
callKey.sources[callKey.sourceCount++] = expression;
|
|
1824
|
+
callKey.isStateKeyed = true;
|
|
1825
|
+
for (let index = 0; index < locals.length; index++) {
|
|
1826
|
+
const local = lookupScope(scope, locals[index]);
|
|
1827
|
+
if (local?.kind !== "Value" || !isEagerValue(local.value)) return false;
|
|
1828
|
+
callKey.args[callKey.argCount++] = local.value;
|
|
1829
|
+
callKey.hash = combineHash(callKey.hash, getKeyHash(local.value));
|
|
1830
|
+
}
|
|
1831
|
+
return true;
|
|
1832
|
+
};
|
|
1833
|
+
|
|
1834
|
+
// Each argument adds to the key what compileArgumentBinder would bind its parameter to.
|
|
1835
|
+
const compileArgumentKey = (
|
|
1836
|
+
argument: Expression,
|
|
1837
|
+
environment: Environment,
|
|
1838
|
+
): ((context: Context) => boolean) => {
|
|
1839
|
+
const isLiteral =
|
|
1840
|
+
argument.kind === "String" || (argument.kind === "Number" && isTlcInteger(argument.value));
|
|
1841
|
+
if (isLiteral) return () => pushKeyValue(argument.value);
|
|
1842
|
+
if (argument.kind === "Identifier") {
|
|
1843
|
+
const global = isLocallyResolved(argument)
|
|
1844
|
+
? undefined
|
|
1845
|
+
: findGlobalName(argument.name, environment);
|
|
1846
|
+
if (global?.kind === "Value") return () => pushKeyValue(global.value);
|
|
1847
|
+
if (global === undefined) {
|
|
1848
|
+
return (context) => {
|
|
1849
|
+
const binding = lookupScope(context.scope, argument.name);
|
|
1850
|
+
if (binding?.kind === "Value") return pushKeyValue(binding.value);
|
|
1851
|
+
if (binding?.kind !== "Thunk" || binding.state !== context.state) return false;
|
|
1852
|
+
return pushKeyExpression(
|
|
1853
|
+
binding.expression,
|
|
1854
|
+
getArgumentLocals(binding.expression, environment),
|
|
1855
|
+
binding.scope,
|
|
1856
|
+
);
|
|
1857
|
+
};
|
|
1858
|
+
}
|
|
1704
1859
|
}
|
|
1705
|
-
|
|
1860
|
+
const locals = getArgumentLocals(argument, environment);
|
|
1861
|
+
return (context) => pushKeyExpression(argument, locals, context.scope);
|
|
1706
1862
|
};
|
|
1707
1863
|
|
|
1708
|
-
const
|
|
1709
|
-
|
|
1864
|
+
const isKnownCall = (call: MemoizedCall) => {
|
|
1865
|
+
if (call.args.length !== callKey.argCount || call.sources.length !== callKey.sourceCount) {
|
|
1866
|
+
return false;
|
|
1867
|
+
}
|
|
1868
|
+
for (let index = 0; index < callKey.sourceCount; index++) {
|
|
1869
|
+
if (call.sources[index] !== callKey.sources[index]) return false;
|
|
1870
|
+
}
|
|
1871
|
+
for (let index = 0; index < callKey.argCount; index++) {
|
|
1872
|
+
if (!isSameValue(call.args[index], callKey.args[index])) return false;
|
|
1873
|
+
}
|
|
1874
|
+
return true;
|
|
1875
|
+
};
|
|
1710
1876
|
|
|
1711
|
-
|
|
1712
|
-
|
|
1713
|
-
|
|
1877
|
+
const findCall = (bucket: MemoizedCall[] | undefined) => {
|
|
1878
|
+
if (bucket === undefined) return undefined;
|
|
1879
|
+
for (let index = 0; index < bucket.length; index++) {
|
|
1880
|
+
if (isKnownCall(bucket[index])) return bucket[index];
|
|
1881
|
+
}
|
|
1882
|
+
return undefined;
|
|
1883
|
+
};
|
|
1884
|
+
|
|
1885
|
+
// An operator without side effects yields the same value for the same arguments, a state-level one
|
|
1886
|
+
// in the same state, so its calls share one result.
|
|
1887
|
+
const getMemoizedLevel = (expression: Expression & { kind: "Apply" }, environment: Environment) => {
|
|
1714
1888
|
const definition = getDefinition(expression.operator, environment);
|
|
1715
|
-
|
|
1889
|
+
const isMemoizable =
|
|
1716
1890
|
definition?.kind === "Operator" &&
|
|
1717
1891
|
definition.params.length > 0 &&
|
|
1718
1892
|
definition.params.every((param) => param.arity === 0) &&
|
|
1719
|
-
|
|
1720
|
-
|
|
1721
|
-
);
|
|
1893
|
+
!isImpureDefinition(definition, environment);
|
|
1894
|
+
if (!isMemoizable) return undefined;
|
|
1895
|
+
if (isConstantLevel(definition, environment)) return "constant";
|
|
1896
|
+
return isStatePure(definition, environment) ? "state" : undefined;
|
|
1722
1897
|
};
|
|
1723
1898
|
|
|
1724
1899
|
const compileClosureCall = (
|
|
1725
1900
|
closure: Closure,
|
|
1726
1901
|
args: Expression[],
|
|
1727
1902
|
environment: Environment,
|
|
1728
|
-
|
|
1903
|
+
memoizedLevel: "constant" | "state" | undefined,
|
|
1729
1904
|
): Evaluator => {
|
|
1730
1905
|
const bindArguments = compileArgumentScope(closure, args, environment);
|
|
1731
1906
|
const compiled = { body: undefined as Evaluator | undefined };
|
|
@@ -1739,23 +1914,49 @@ const compileClosureCall = (
|
|
|
1739
1914
|
isKeepLazy: context.isKeepLazy,
|
|
1740
1915
|
});
|
|
1741
1916
|
};
|
|
1742
|
-
if (!
|
|
1743
|
-
|
|
1917
|
+
if (!memoizedLevel || args.length !== closure.params.length) {
|
|
1918
|
+
return (context) => evaluateBody(bindArguments(context), context);
|
|
1919
|
+
}
|
|
1920
|
+
const memos = getCallMemos(closure);
|
|
1921
|
+
const keys = args.map((arg) => compileArgumentKey(arg, environment));
|
|
1922
|
+
const usage = { hits: 0, misses: 0 };
|
|
1744
1923
|
return (context) => {
|
|
1745
|
-
const scope = bindArguments(context);
|
|
1746
|
-
const values = getArgumentValues(scope, args.length);
|
|
1747
1924
|
// A call TLC evaluates with EvalControl.KeepLazy builds what a memoized one wouldn't.
|
|
1748
|
-
if (
|
|
1749
|
-
|
|
1750
|
-
|
|
1925
|
+
if (context.isKeepLazy) return evaluateBody(bindArguments(context), context);
|
|
1926
|
+
callKey.sourceCount = 0;
|
|
1927
|
+
callKey.argCount = 0;
|
|
1928
|
+
callKey.hash = args.length;
|
|
1929
|
+
callKey.isStateKeyed = false;
|
|
1930
|
+
for (let index = 0; index < keys.length; index++) {
|
|
1931
|
+
if (!keys[index](context)) return evaluateBody(bindArguments(context), context);
|
|
1932
|
+
}
|
|
1933
|
+
const isStateKeyed = memoizedLevel === "state" || callKey.isStateKeyed;
|
|
1934
|
+
if (isStateKeyed && usage.misses > MEMOIZED_TRIAL_CALLS && usage.hits < usage.misses) {
|
|
1935
|
+
return evaluateBody(bindArguments(context), context);
|
|
1936
|
+
}
|
|
1937
|
+
const memo = isStateKeyed ? memos.state : memos.constant;
|
|
1938
|
+
if (isStateKeyed && memo.state !== context.state) {
|
|
1939
|
+
memo.state = context.state;
|
|
1940
|
+
memo.calls.clear();
|
|
1941
|
+
memo.size = 0;
|
|
1942
|
+
}
|
|
1943
|
+
// A small integer key keeps the Map from boxing it.
|
|
1944
|
+
const hash = callKey.hash & 0x3fffffff;
|
|
1751
1945
|
const bucket = memo.calls.get(hash);
|
|
1752
|
-
const known = bucket
|
|
1753
|
-
if (known)
|
|
1754
|
-
|
|
1946
|
+
const known = findCall(bucket);
|
|
1947
|
+
if (known) {
|
|
1948
|
+
if (isStateKeyed) usage.hits++;
|
|
1949
|
+
return known.value;
|
|
1950
|
+
}
|
|
1951
|
+
if (isStateKeyed) usage.misses++;
|
|
1952
|
+
const sources = callKey.sources.slice(0, callKey.sourceCount);
|
|
1953
|
+
const keyArgs = callKey.args.slice(0, callKey.argCount);
|
|
1954
|
+
const value = evaluateBody(bindArguments(context), context);
|
|
1755
1955
|
if (memo.size < MEMOIZED_CALL_LIMIT) {
|
|
1756
1956
|
memo.size++;
|
|
1757
|
-
|
|
1758
|
-
|
|
1957
|
+
const call = { sources, args: keyArgs, value };
|
|
1958
|
+
if (bucket) bucket.push(call);
|
|
1959
|
+
else memo.calls.set(hash, [call]);
|
|
1759
1960
|
}
|
|
1760
1961
|
return value;
|
|
1761
1962
|
};
|
|
@@ -1783,8 +1984,10 @@ const compileApply = (
|
|
|
1783
1984
|
: resolveGlobalOperator(expression.operator, environment);
|
|
1784
1985
|
if (global?.kind === "Closure") {
|
|
1785
1986
|
// The replay records the evaluation of each call, which TLC repeats.
|
|
1786
|
-
const
|
|
1787
|
-
|
|
1987
|
+
const memoizedLevel = environment.callStack
|
|
1988
|
+
? undefined
|
|
1989
|
+
: getMemoizedLevel(expression, environment);
|
|
1990
|
+
return compileClosureCall(global, args, environment, memoizedLevel);
|
|
1788
1991
|
}
|
|
1789
1992
|
if (global?.kind === "Builtin" && global.name === "DOMAIN") {
|
|
1790
1993
|
const operand = getEvaluator(args[0], environment);
|
|
@@ -1817,9 +2020,11 @@ const compileApply = (
|
|
|
1817
2020
|
);
|
|
1818
2021
|
};
|
|
1819
2022
|
}
|
|
2023
|
+
const called = { entry: undefined as CalledBody | undefined };
|
|
2024
|
+
const binders = args.map((arg) => getArgumentBinder(arg, environment));
|
|
1820
2025
|
return (context) => {
|
|
1821
2026
|
const operator = resolveOperator(expression.operator, context);
|
|
1822
|
-
if (operator) return callOperator(operator, args, context);
|
|
2027
|
+
if (operator) return callOperator(operator, args, context, called, binders);
|
|
1823
2028
|
const definition = environment.definitions.get(expression.operator);
|
|
1824
2029
|
if (definition?.kind === "Function") {
|
|
1825
2030
|
throw new TlaEvaluationError(`${expression.operator} is a function; apply it with brackets`);
|
|
@@ -1882,7 +2087,7 @@ const compileQuantifier = (
|
|
|
1882
2087
|
};
|
|
1883
2088
|
};
|
|
1884
2089
|
|
|
1885
|
-
const
|
|
2090
|
+
const getBoundValue = (pattern: BoundPattern, scope: Scope | undefined) => {
|
|
1886
2091
|
if (pattern.kind === "Tuple") {
|
|
1887
2092
|
return createTuple(
|
|
1888
2093
|
pattern.names.map((name) => {
|
|
@@ -1937,8 +2142,8 @@ const compileFunctionConstruction = (
|
|
|
1937
2142
|
forEachBoundElement(bounds, sets, context.scope, (scope) => {
|
|
1938
2143
|
const key =
|
|
1939
2144
|
bounds.length === 1
|
|
1940
|
-
? (
|
|
1941
|
-
: createTuple(bounds.map((item) =>
|
|
2145
|
+
? (getBoundValue(bound.pattern, scope) ?? false)
|
|
2146
|
+
: createTuple(bounds.map((item) => getBoundValue(item.pattern, scope) ?? false));
|
|
1942
2147
|
pairs.push([key, body(withScope(context, scope))]);
|
|
1943
2148
|
return false;
|
|
1944
2149
|
});
|
|
@@ -2069,22 +2274,18 @@ const compileSetComprehension = (
|
|
|
2069
2274
|
base: Value,
|
|
2070
2275
|
context: Context,
|
|
2071
2276
|
evaluator: Evaluator,
|
|
2072
|
-
):
|
|
2073
|
-
|
|
2074
|
-
|
|
2075
|
-
|
|
2076
|
-
|
|
2077
|
-
|
|
2078
|
-
};
|
|
2079
|
-
filteredSetRebinders.set(filtered, (tracing) =>
|
|
2277
|
+
): RebindableFilteredSet => ({
|
|
2278
|
+
kind: "FilteredSet",
|
|
2279
|
+
base,
|
|
2280
|
+
test: createTest(evaluator, context),
|
|
2281
|
+
source,
|
|
2282
|
+
rebind: (tracing) =>
|
|
2080
2283
|
createFiltered(
|
|
2081
2284
|
base,
|
|
2082
2285
|
{ ...context, environment: tracing },
|
|
2083
2286
|
getEvaluator(expression.predicate, tracing),
|
|
2084
2287
|
),
|
|
2085
|
-
|
|
2086
|
-
return filtered;
|
|
2087
|
-
};
|
|
2288
|
+
});
|
|
2088
2289
|
return (context) => {
|
|
2089
2290
|
const base = set(context);
|
|
2090
2291
|
// TLC filters any value it can't enumerate lazily, and fails only when it uses the result.
|
|
@@ -2125,7 +2326,7 @@ const compileSetComprehension = (
|
|
|
2125
2326
|
someElement(elements, (element) => {
|
|
2126
2327
|
const scope = bindPattern(context.scope, expression.pattern, element);
|
|
2127
2328
|
if (!expectBoolean(body(withScope(context, scope)), "the body of CHOOSE")) return false;
|
|
2128
|
-
chosen.value =
|
|
2329
|
+
chosen.value = getBoundValue(expression.pattern, scope);
|
|
2129
2330
|
return true;
|
|
2130
2331
|
});
|
|
2131
2332
|
if (chosen.value === undefined) {
|
|
@@ -2144,27 +2345,6 @@ export const getSortedFields = (fields: RecordField[]) =>
|
|
|
2144
2345
|
export const hasDuplicateFields = (sortedFields: RecordField[]) =>
|
|
2145
2346
|
sortedFields.some((field, index) => index > 0 && sortedFields[index - 1].name === field.name);
|
|
2146
2347
|
|
|
2147
|
-
// TLC's Tool#evalAppl fails to look up a variable the state doesn't assign.
|
|
2148
|
-
export const createUnassignedError = (name: string, expression: Expression) =>
|
|
2149
|
-
new TlaUnassignedError(
|
|
2150
|
-
`In evaluation, the identifier ${name} is either undefined or not an operator.\n${describeRange(expression)}`,
|
|
2151
|
-
name,
|
|
2152
|
-
);
|
|
2153
|
-
|
|
2154
|
-
// TLC's Tool#enabled reads the subscript of <<A>>_v in the successor as a state of its own, and
|
|
2155
|
-
// names the fairness condition when A leaves a variable of v unassigned, unlike TLC 1.7.4's.
|
|
2156
|
-
export const toUnspecifiedSubscriptError = (error: unknown, version: TlcVersion | undefined) =>
|
|
2157
|
-
error instanceof TlaUnassignedError && version !== "1.7.4"
|
|
2158
|
-
? new TlaEvaluationError(
|
|
2159
|
-
`The action formula A appearing in a WF_v(A) or SF_v(A) operator does not specify the primed value of the variable ${error.variable} occurring in the state formula v.\n`,
|
|
2160
|
-
)
|
|
2161
|
-
: error;
|
|
2162
|
-
|
|
2163
|
-
export const createPrimeOutsideActionError = (expression: Expression) =>
|
|
2164
|
-
new TlaEvaluationError(
|
|
2165
|
-
`A primed expression appears outside an action at ${describeLocation(expression)}`,
|
|
2166
|
-
);
|
|
2167
|
-
|
|
2168
2348
|
const compileRecord = (recordFields: RecordField[], environment: Environment): Evaluator => {
|
|
2169
2349
|
const fields = getSortedFields(recordFields);
|
|
2170
2350
|
const hasDuplicates = hasDuplicateFields(fields);
|
|
@@ -2193,7 +2373,7 @@ const compileRecord = (recordFields: RecordField[], environment: Environment): E
|
|
|
2193
2373
|
};
|
|
2194
2374
|
|
|
2195
2375
|
const compile = (expression: Expression, environment: Environment): Evaluator => {
|
|
2196
|
-
const
|
|
2376
|
+
const getChildEvaluator = (node: Expression) => getEvaluator(node, environment);
|
|
2197
2377
|
switch (expression.kind) {
|
|
2198
2378
|
case "Number": {
|
|
2199
2379
|
const value = expression.value;
|
|
@@ -2229,29 +2409,29 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2229
2409
|
);
|
|
2230
2410
|
};
|
|
2231
2411
|
case "And": {
|
|
2232
|
-
const operands = expression.operands.map(
|
|
2412
|
+
const operands = expression.operands.map(getChildEvaluator);
|
|
2233
2413
|
return (context) => {
|
|
2234
2414
|
for (let index = 0; index < operands.length; index++) {
|
|
2235
2415
|
const value = operands[index](context);
|
|
2236
|
-
if (typeof value !== "boolean") throw
|
|
2416
|
+
if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
|
|
2237
2417
|
if (!value) return false;
|
|
2238
2418
|
}
|
|
2239
2419
|
return true;
|
|
2240
2420
|
};
|
|
2241
2421
|
}
|
|
2242
2422
|
case "Or": {
|
|
2243
|
-
const operands = expression.operands.map(
|
|
2423
|
+
const operands = expression.operands.map(getChildEvaluator);
|
|
2244
2424
|
return (context) => {
|
|
2245
2425
|
for (let index = 0; index < operands.length; index++) {
|
|
2246
2426
|
const value = operands[index](context);
|
|
2247
|
-
if (typeof value !== "boolean") throw
|
|
2427
|
+
if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
|
|
2248
2428
|
if (value) return true;
|
|
2249
2429
|
}
|
|
2250
2430
|
return false;
|
|
2251
2431
|
};
|
|
2252
2432
|
}
|
|
2253
2433
|
case "Prime": {
|
|
2254
|
-
const inner =
|
|
2434
|
+
const inner = getChildEvaluator(expression.expression);
|
|
2255
2435
|
return (context) => {
|
|
2256
2436
|
if (!context.next) throw createPrimeOutsideActionError(expression);
|
|
2257
2437
|
return inner({
|
|
@@ -2264,31 +2444,31 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2264
2444
|
};
|
|
2265
2445
|
}
|
|
2266
2446
|
case "Unchanged": {
|
|
2267
|
-
const primed =
|
|
2447
|
+
const primed = getChildEvaluator({
|
|
2268
2448
|
kind: "Prime",
|
|
2269
2449
|
expression: expression.expression,
|
|
2270
2450
|
location: expression.location,
|
|
2271
2451
|
});
|
|
2272
|
-
const current =
|
|
2452
|
+
const current = getChildEvaluator(expression.expression);
|
|
2273
2453
|
return (context) => valuesEqual(primed(context), current(context));
|
|
2274
2454
|
}
|
|
2275
2455
|
case "If": {
|
|
2276
|
-
const condition =
|
|
2277
|
-
const consequent =
|
|
2278
|
-
const alternative =
|
|
2456
|
+
const condition = getChildEvaluator(expression.condition);
|
|
2457
|
+
const consequent = getChildEvaluator(expression.consequent);
|
|
2458
|
+
const alternative = getChildEvaluator(expression.alternative);
|
|
2279
2459
|
return (context) => {
|
|
2280
2460
|
const value = condition(context);
|
|
2281
|
-
if (typeof value !== "boolean") throw
|
|
2461
|
+
if (typeof value !== "boolean") throw createConditionError(expression, value);
|
|
2282
2462
|
return value ? consequent(context) : alternative(context);
|
|
2283
2463
|
};
|
|
2284
2464
|
}
|
|
2285
2465
|
case "Case": {
|
|
2286
2466
|
const arms = expression.arms.map((arm) => ({
|
|
2287
2467
|
source: arm.condition,
|
|
2288
|
-
condition:
|
|
2289
|
-
body:
|
|
2468
|
+
condition: getChildEvaluator(arm.condition),
|
|
2469
|
+
body: getChildEvaluator(arm.body),
|
|
2290
2470
|
}));
|
|
2291
|
-
const other = expression.other ?
|
|
2471
|
+
const other = expression.other ? getChildEvaluator(expression.other) : undefined;
|
|
2292
2472
|
return (context) => {
|
|
2293
2473
|
for (const arm of arms) {
|
|
2294
2474
|
const value = arm.condition(context);
|
|
@@ -2306,7 +2486,7 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2306
2486
|
};
|
|
2307
2487
|
}
|
|
2308
2488
|
case "Let": {
|
|
2309
|
-
const body =
|
|
2489
|
+
const body = getChildEvaluator(expression.body);
|
|
2310
2490
|
return (context) =>
|
|
2311
2491
|
body(withScope(context, bindDefinitions(expression.definitions, context)));
|
|
2312
2492
|
}
|
|
@@ -2324,18 +2504,18 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2324
2504
|
case "SetMap":
|
|
2325
2505
|
return compileSetComprehension(expression, environment);
|
|
2326
2506
|
case "SetEnumeration": {
|
|
2327
|
-
const elements = expression.elements.map(
|
|
2507
|
+
const elements = expression.elements.map(getChildEvaluator);
|
|
2328
2508
|
return (context) => createEnumeratedSet(elements.map((element) => element(context)));
|
|
2329
2509
|
}
|
|
2330
2510
|
case "Tuple": {
|
|
2331
|
-
const elements = expression.elements.map(
|
|
2511
|
+
const elements = expression.elements.map(getChildEvaluator);
|
|
2332
2512
|
return (context) => createTuple(elements.map((element) => element(context)));
|
|
2333
2513
|
}
|
|
2334
2514
|
case "FunctionConstruction":
|
|
2335
2515
|
return compileFunctionConstruction(expression, environment);
|
|
2336
2516
|
case "FunctionSet": {
|
|
2337
|
-
const domain =
|
|
2338
|
-
const range =
|
|
2517
|
+
const domain = getChildEvaluator(expression.domain);
|
|
2518
|
+
const range = getChildEvaluator(expression.range);
|
|
2339
2519
|
return (context) => ({ kind: "FunctionSet", domain: domain(context), range: range(context) });
|
|
2340
2520
|
}
|
|
2341
2521
|
case "Record":
|
|
@@ -2343,7 +2523,7 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2343
2523
|
case "RecordSet": {
|
|
2344
2524
|
const fields = getSortedFields(expression.fields);
|
|
2345
2525
|
const names = fields.map((field) => field.name);
|
|
2346
|
-
const sets = fields.map((field) =>
|
|
2526
|
+
const sets = fields.map((field) => getChildEvaluator(field.value));
|
|
2347
2527
|
return (context) => ({ kind: "RecordSet", names, sets: sets.map((set) => set(context)) });
|
|
2348
2528
|
}
|
|
2349
2529
|
case "Except":
|
|
@@ -2360,10 +2540,10 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2360
2540
|
};
|
|
2361
2541
|
case "FunctionApplication": {
|
|
2362
2542
|
keepLazy(expression.function);
|
|
2363
|
-
const evaluated =
|
|
2543
|
+
const evaluated = getChildEvaluator(expression.function);
|
|
2364
2544
|
const evaluateFunction = (context: Context) =>
|
|
2365
2545
|
expectFunction(evaluated(toKeepLazyContext(context)), expression);
|
|
2366
|
-
const args = expression.args.map(
|
|
2546
|
+
const args = expression.args.map(getChildEvaluator);
|
|
2367
2547
|
const describeMissing = getMissingArgumentDescriber(environment.runtime.version);
|
|
2368
2548
|
if (args.length === 1) {
|
|
2369
2549
|
const argument = args[0];
|
|
@@ -2378,12 +2558,12 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2378
2558
|
);
|
|
2379
2559
|
}
|
|
2380
2560
|
case "FieldAccess": {
|
|
2381
|
-
const record =
|
|
2561
|
+
const record = getChildEvaluator(expression.record);
|
|
2382
2562
|
const select = getFieldSelector(expression);
|
|
2383
2563
|
return (context) => select(record(context));
|
|
2384
2564
|
}
|
|
2385
2565
|
case "Product": {
|
|
2386
|
-
const factors = expression.factors.map(
|
|
2566
|
+
const factors = expression.factors.map(getChildEvaluator);
|
|
2387
2567
|
return (context) => ({
|
|
2388
2568
|
kind: "ProductSet",
|
|
2389
2569
|
factors: factors.map((factor) => factor(context)),
|
|
@@ -2391,8 +2571,8 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2391
2571
|
}
|
|
2392
2572
|
case "BoxAction":
|
|
2393
2573
|
case "AngleAction": {
|
|
2394
|
-
const action =
|
|
2395
|
-
const unchanged =
|
|
2574
|
+
const action = getChildEvaluator(expression.action);
|
|
2575
|
+
const unchanged = getChildEvaluator({
|
|
2396
2576
|
kind: "Unchanged",
|
|
2397
2577
|
expression: expression.subscript,
|
|
2398
2578
|
location: expression.location,
|
|
@@ -2408,7 +2588,7 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2408
2588
|
return (context) => isEnabled(action, context);
|
|
2409
2589
|
}
|
|
2410
2590
|
case "Label":
|
|
2411
|
-
return
|
|
2591
|
+
return getChildEvaluator(expression.body);
|
|
2412
2592
|
case "Subexpression":
|
|
2413
2593
|
return () => {
|
|
2414
2594
|
throw new TlaEvaluationError(
|