tla-ts 0.0.9 → 0.0.10-dev.28c823e4b

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