tla-ts 0.0.9 → 0.0.10-dev.63a6693bd

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 (400) 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 +29 -29
  5. package/dist/deciders.js +42 -42
  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 +117 -37
  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 +48 -62
  26. package/src/bags.ts +99 -102
  27. package/src/builtins.ts +28 -75
  28. package/src/bundled-modules.ts +1 -8
  29. package/src/check-failure.ts +116 -0
  30. package/src/check-trace.ts +282 -0
  31. package/src/check.ts +599 -754
  32. package/src/cli/options.ts +12 -32
  33. package/src/cli/run.ts +0 -2
  34. package/src/cli/runtime-invariants.ts +136 -0
  35. package/src/cli/shared.ts +19 -12
  36. package/src/cli/tlapm.ts +14 -25
  37. package/src/cli/tlc-arguments.ts +652 -0
  38. package/src/cli/tlc-output.ts +687 -0
  39. package/src/cli/tlc-usage.ts +361 -0
  40. package/src/cli/tlc.ts +309 -658
  41. package/src/cli/typescript.ts +23 -0
  42. package/src/cli/xml-exporter.ts +27 -49
  43. package/src/cli.ts +0 -1
  44. package/src/codegen.ts +196 -74
  45. package/src/config.ts +140 -109
  46. package/src/coverage.ts +830 -0
  47. package/src/dependencies.ts +14 -53
  48. package/src/dfid.ts +618 -0
  49. package/src/environment-config.ts +315 -0
  50. package/src/environment.ts +169 -335
  51. package/src/errors.ts +71 -55
  52. package/src/evaluate.ts +598 -340
  53. package/src/exit-codes.ts +37 -3
  54. package/src/fingerprints.ts +75 -11
  55. package/src/index.ts +3 -0
  56. package/src/instances.ts +126 -21
  57. package/src/java-hash.ts +7 -0
  58. package/src/java-overrides.ts +4 -19
  59. package/src/json-reader.ts +455 -0
  60. package/src/json.ts +252 -139
  61. package/src/levels.ts +46 -58
  62. package/src/lexer.ts +80 -100
  63. package/src/liveness-checker.ts +103 -153
  64. package/src/liveness.ts +150 -109
  65. package/src/obligations/action.ts +8 -39
  66. package/src/obligations/anonymize.ts +88 -82
  67. package/src/obligations/equality.ts +1 -1
  68. package/src/obligations/expression.ts +20 -21
  69. package/src/obligations/format.ts +1 -9
  70. package/src/obligations/generate.ts +46 -49
  71. package/src/obligations/index.ts +2 -13
  72. package/src/obligations/levels.ts +4 -8
  73. package/src/obligations/module.ts +28 -53
  74. package/src/obligations/normalize.ts +7 -25
  75. package/src/obligations/operators.ts +1 -2
  76. package/src/obligations/pragma.ts +1 -10
  77. package/src/obligations/printer.ts +47 -46
  78. package/src/obligations/proof.ts +1 -5
  79. package/src/obligations/regroup.ts +1 -4
  80. package/src/obligations/simplify.ts +42 -58
  81. package/src/obligations/source.ts +48 -78
  82. package/src/obligations/subexpression.ts +5 -11
  83. package/src/obligations/substitution.ts +1 -3
  84. package/src/obligations/temporal.ts +13 -19
  85. package/src/obligations/tuples.ts +3 -9
  86. package/src/parallel-worker.ts +30 -60
  87. package/src/parallel.ts +57 -71
  88. package/src/parser.ts +584 -316
  89. package/src/pcal/ast.ts +53 -86
  90. package/src/pcal/parse.ts +144 -219
  91. package/src/pcal/tokenize.ts +91 -131
  92. package/src/pcal/translate.ts +83 -130
  93. package/src/pcal/validate.ts +48 -68
  94. package/src/pretty-print.ts +7 -8
  95. package/src/prover/decide-pool.ts +8 -13
  96. package/src/prover/deciders.ts +3 -7
  97. package/src/prover/first-order.ts +0 -11
  98. package/src/prover/isabelle/decide.ts +0 -6
  99. package/src/prover/isabelle/encode.ts +11 -23
  100. package/src/prover/isabelle/isar/inner-syntax.ts +114 -115
  101. package/src/prover/isabelle/isar/method.ts +29 -53
  102. package/src/prover/isabelle/isar/proof.ts +1 -10
  103. package/src/prover/isabelle/isar/statement.ts +1 -6
  104. package/src/prover/isabelle/isar/theory.ts +26 -36
  105. package/src/prover/isabelle/isar/type-check.ts +17 -31
  106. package/src/prover/isabelle/provers/blast/blast.ts +17 -104
  107. package/src/prover/isabelle/provers/blast/branch.ts +1 -32
  108. package/src/prover/isabelle/provers/blast/prove.ts +1 -35
  109. package/src/prover/isabelle/provers/blast/rules.ts +6 -44
  110. package/src/prover/isabelle/provers/blast/state.ts +2 -28
  111. package/src/prover/isabelle/provers/blast/term.ts +9 -36
  112. package/src/prover/isabelle/provers/clasimp.ts +1 -13
  113. package/src/prover/isabelle/provers/classical.ts +14 -42
  114. package/src/prover/isabelle/provers/hypsubst.ts +28 -51
  115. package/src/prover/isabelle/pure/bicompose.ts +25 -38
  116. package/src/prover/isabelle/pure/consts.ts +1 -7
  117. package/src/prover/isabelle/pure/conv.ts +3 -17
  118. package/src/prover/isabelle/pure/drule.ts +33 -42
  119. package/src/prover/isabelle/pure/envir.ts +3 -52
  120. package/src/prover/isabelle/pure/goal.ts +1 -7
  121. package/src/prover/isabelle/pure/interrupt.ts +0 -5
  122. package/src/prover/isabelle/pure/list.ts +0 -3
  123. package/src/prover/isabelle/pure/logic.ts +2 -15
  124. package/src/prover/isabelle/pure/name.ts +2 -9
  125. package/src/prover/isabelle/pure/net.ts +3 -59
  126. package/src/prover/isabelle/pure/object-logic.ts +3 -10
  127. package/src/prover/isabelle/pure/pattern.ts +2 -19
  128. package/src/prover/isabelle/pure/raw-simplifier.ts +17 -62
  129. package/src/prover/isabelle/pure/rewriter.ts +31 -67
  130. package/src/prover/isabelle/pure/search.ts +3 -10
  131. package/src/prover/isabelle/pure/seq.ts +1 -10
  132. package/src/prover/isabelle/pure/simplifier.ts +4 -12
  133. package/src/prover/isabelle/pure/table.ts +3 -32
  134. package/src/prover/isabelle/pure/tactic.ts +12 -22
  135. package/src/prover/isabelle/pure/tactical.ts +48 -47
  136. package/src/prover/isabelle/pure/term-ord.ts +2 -6
  137. package/src/prover/isabelle/pure/term.ts +2 -43
  138. package/src/prover/isabelle/pure/thm.ts +27 -47
  139. package/src/prover/isabelle/pure/type.ts +2 -15
  140. package/src/prover/isabelle/pure/unify.ts +20 -30
  141. package/src/prover/isabelle/pure/variable.ts +3 -7
  142. package/src/prover/isabelle/tla/classical-setup.ts +17 -24
  143. package/src/prover/isabelle/tla/context.ts +15 -18
  144. package/src/prover/isabelle/tla/logic.ts +14 -32
  145. package/src/prover/isabelle/tla/simpdata.ts +46 -43
  146. package/src/prover/isabelle/tools/intuitionistic.ts +1 -10
  147. package/src/prover/ocaml.ts +0 -6
  148. package/src/prover/prep/action.ts +14 -54
  149. package/src/prover/prep/enabled-axioms.ts +12 -19
  150. package/src/prover/prep/fingerprint.ts +2 -21
  151. package/src/prover/prep/level-comparison.ts +8 -12
  152. package/src/prover/prep/md5.ts +0 -2
  153. package/src/prover/prep/methods.ts +33 -39
  154. package/src/prover/prep/normalize.ts +4 -28
  155. package/src/prover/prove-worker.ts +0 -2
  156. package/src/prover/prove.ts +87 -100
  157. package/src/prover/ptl/decide.ts +7 -12
  158. package/src/prover/ptl/encode.ts +14 -36
  159. package/src/prover/ptl/sat.ts +24 -32
  160. package/src/prover/ptl/tableau.ts +12 -26
  161. package/src/prover/smt/axioms.ts +0 -7
  162. package/src/prover/smt/context.ts +20 -28
  163. package/src/prover/smt/data.ts +433 -424
  164. package/src/prover/smt/encode.ts +43 -52
  165. package/src/prover/smt/extensionality.ts +0 -10
  166. package/src/prover/smt/flatten.ts +3 -22
  167. package/src/prover/smt/format.ts +5 -10
  168. package/src/prover/smt/instances.ts +0 -10
  169. package/src/prover/smt/rewrite.ts +663 -667
  170. package/src/prover/smt/solver/act-cache.ts +0 -15
  171. package/src/prover/smt/solver/arith-rewriter.ts +3 -48
  172. package/src/prover/smt/solver/array.ts +1 -3
  173. package/src/prover/smt/solver/asserted-formulas.ts +1 -43
  174. package/src/prover/smt/solver/ast-lt.ts +1 -11
  175. package/src/prover/smt/solver/ast-util.ts +1 -6
  176. package/src/prover/smt/solver/ast.ts +1 -165
  177. package/src/prover/smt/solver/auf-solver.ts +8 -44
  178. package/src/prover/smt/solver/case-split-queue.ts +1 -9
  179. package/src/prover/smt/solver/cg-table.ts +1 -18
  180. package/src/prover/smt/solver/clause.ts +1 -27
  181. package/src/prover/smt/solver/conflict-resolution.ts +0 -9
  182. package/src/prover/smt/solver/context.ts +7 -64
  183. package/src/prover/smt/solver/ctx-simplify.ts +14 -41
  184. package/src/prover/smt/solver/der.ts +2 -21
  185. package/src/prover/smt/solver/dyn-ack.ts +1 -11
  186. package/src/prover/smt/solver/e-matching.ts +4 -35
  187. package/src/prover/smt/solver/enode.ts +1 -21
  188. package/src/prover/smt/solver/expr-ref.ts +1 -5
  189. package/src/prover/smt/solver/expr-safe-replace.ts +1 -6
  190. package/src/prover/smt/solver/fingerprints.ts +1 -12
  191. package/src/prover/smt/solver/flat-literals.ts +1 -9
  192. package/src/prover/smt/solver/goal.ts +2 -14
  193. package/src/prover/smt/solver/hash.ts +0 -8
  194. package/src/prover/smt/solver/hashtable.ts +1 -12
  195. package/src/prover/smt/solver/internalizer.ts +7 -100
  196. package/src/prover/smt/solver/lbool.ts +1 -2
  197. package/src/prover/smt/solver/literal.ts +0 -3
  198. package/src/prover/smt/solver/lp/bound-propagator.ts +8 -26
  199. package/src/prover/smt/solver/lp/constraints.ts +2 -8
  200. package/src/prover/smt/solver/lp/containers.ts +12 -30
  201. package/src/prover/smt/solver/lp/core-solver.ts +10 -31
  202. package/src/prover/smt/solver/lp/cross-nested.ts +6 -20
  203. package/src/prover/smt/solver/lp/dep-intervals.ts +7 -22
  204. package/src/prover/smt/solver/lp/dependency.ts +1 -4
  205. package/src/prover/smt/solver/lp/dioph-eq.ts +9 -102
  206. package/src/prover/smt/solver/lp/explanation.ts +1 -6
  207. package/src/prover/smt/solver/lp/gomory.ts +9 -22
  208. package/src/prover/smt/solver/lp/hnf-cutter.ts +17 -23
  209. package/src/prover/smt/solver/lp/hnf.ts +11 -26
  210. package/src/prover/smt/solver/lp/int-cube.ts +15 -36
  211. package/src/prover/smt/solver/lp/int-solver.ts +4 -34
  212. package/src/prover/smt/solver/lp/lar-solver.ts +32 -81
  213. package/src/prover/smt/solver/lp/lar-term.ts +1 -5
  214. package/src/prover/smt/solver/lp/lp-settings.ts +1 -14
  215. package/src/prover/smt/solver/lp/maximize-term.ts +20 -45
  216. package/src/prover/smt/solver/lp/nex-creator.ts +5 -28
  217. package/src/prover/smt/solver/lp/nex.ts +1 -6
  218. package/src/prover/smt/solver/lp/nla-backoff.ts +1 -4
  219. package/src/prover/smt/solver/lp/nla-basics.ts +5 -30
  220. package/src/prover/smt/solver/lp/nla-core.ts +36 -135
  221. package/src/prover/smt/solver/lp/nla-divisions.ts +32 -42
  222. package/src/prover/smt/solver/lp/nla-emonics.ts +4 -21
  223. package/src/prover/smt/solver/lp/nla-factorization.ts +1 -4
  224. package/src/prover/smt/solver/lp/nla-grobner.ts +15 -69
  225. package/src/prover/smt/solver/lp/nla-horner.ts +3 -11
  226. package/src/prover/smt/solver/lp/nla-intervals.ts +2 -12
  227. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +16 -41
  228. package/src/prover/smt/solver/lp/nla-monotone.ts +2 -6
  229. package/src/prover/smt/solver/lp/nla-order.ts +2 -13
  230. package/src/prover/smt/solver/lp/nla-patcher.ts +4 -7
  231. package/src/prover/smt/solver/lp/nla-tangents.ts +1 -9
  232. package/src/prover/smt/solver/lp/nla-throttle.ts +1 -6
  233. package/src/prover/smt/solver/lp/nla-types.ts +1 -11
  234. package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -25
  235. package/src/prover/smt/solver/lp/nra-solver.ts +5 -52
  236. package/src/prover/smt/solver/lp/numeric-pair.ts +1 -4
  237. package/src/prover/smt/solver/lp/pdd-interval.ts +1 -3
  238. package/src/prover/smt/solver/lp/pdd-simplifier.ts +2 -14
  239. package/src/prover/smt/solver/lp/pdd-solver.ts +4 -33
  240. package/src/prover/smt/solver/lp/pdd.ts +7 -70
  241. package/src/prover/smt/solver/lp/random-updater.ts +1 -8
  242. package/src/prover/smt/solver/lp/static-matrix.ts +9 -19
  243. package/src/prover/smt/solver/lp/union-find.ts +1 -6
  244. package/src/prover/smt/solver/mam-compiler.ts +18 -58
  245. package/src/prover/smt/solver/mam-interpreter.ts +1 -21
  246. package/src/prover/smt/solver/maximize-ac-sharing.ts +2 -17
  247. package/src/prover/smt/solver/model-checker.ts +3 -37
  248. package/src/prover/smt/solver/model-evaluator.ts +3 -29
  249. package/src/prover/smt/solver/model-finder.ts +15 -32
  250. package/src/prover/smt/solver/model-generator.ts +1 -12
  251. package/src/prover/smt/solver/model-macro-solver.ts +23 -88
  252. package/src/prover/smt/solver/nlsat/algebraic.ts +63 -159
  253. package/src/prover/smt/solver/nlsat/atoms.ts +25 -23
  254. package/src/prover/smt/solver/nlsat/evaluator.ts +17 -22
  255. package/src/prover/smt/solver/nlsat/explain.ts +10 -69
  256. package/src/prover/smt/solver/nlsat/interval-set.ts +9 -50
  257. package/src/prover/smt/solver/nlsat/levelwise.ts +49 -135
  258. package/src/prover/smt/solver/nlsat/mpbq.ts +3 -14
  259. package/src/prover/smt/solver/nlsat/polynomial.ts +29 -159
  260. package/src/prover/smt/solver/nlsat/solver.ts +18 -90
  261. package/src/prover/smt/solver/nlsat/types.ts +1 -8
  262. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +2 -45
  263. package/src/prover/smt/solver/nlsat/upolynomial.ts +11 -92
  264. package/src/prover/smt/solver/nnf.ts +3 -38
  265. package/src/prover/smt/solver/pattern-inference.ts +2 -15
  266. package/src/prover/smt/solver/poly-rewriter.ts +3 -23
  267. package/src/prover/smt/solver/propagate-values.ts +1 -10
  268. package/src/prover/smt/solver/proto-model.ts +3 -52
  269. package/src/prover/smt/solver/pull-quant.ts +1 -12
  270. package/src/prover/smt/solver/qe-lite-der.ts +1 -29
  271. package/src/prover/smt/solver/qe-lite-fm.ts +2 -25
  272. package/src/prover/smt/solver/qe-lite.ts +3 -33
  273. package/src/prover/smt/solver/qi-queue.ts +1 -16
  274. package/src/prover/smt/solver/quant-tactics.ts +5 -22
  275. package/src/prover/smt/solver/quantifier-analyzer.ts +27 -47
  276. package/src/prover/smt/solver/quantifier-manager.ts +2 -13
  277. package/src/prover/smt/solver/random-gen.ts +1 -2
  278. package/src/prover/smt/solver/rational.ts +1 -8
  279. package/src/prover/smt/solver/ref-vector.ts +1 -6
  280. package/src/prover/smt/solver/relevancy.ts +2 -15
  281. package/src/prover/smt/solver/rewriter-tpl.ts +3 -147
  282. package/src/prover/smt/solver/rewriter.ts +3 -85
  283. package/src/prover/smt/solver/rlimit.ts +2 -20
  284. package/src/prover/smt/solver/smtlib-parser.ts +80 -131
  285. package/src/prover/smt/solver/solver.ts +23 -34
  286. package/src/prover/smt/solver/sort.ts +1 -5
  287. package/src/prover/smt/solver/sticky-generations.ts +0 -5
  288. package/src/prover/smt/solver/theory-lra-axioms.ts +3 -24
  289. package/src/prover/smt/solver/theory-lra-bounds.ts +1 -7
  290. package/src/prover/smt/solver/theory-lra-final-check.ts +4 -22
  291. package/src/prover/smt/solver/theory-lra-internalize.ts +6 -43
  292. package/src/prover/smt/solver/theory-lra-model.ts +4 -19
  293. package/src/prover/smt/solver/theory-lra-propagate.ts +1 -15
  294. package/src/prover/smt/solver/theory-lra-state.ts +3 -8
  295. package/src/prover/smt/solver/theory-lra.ts +1 -8
  296. package/src/prover/smt/solver/var-subst.ts +2 -26
  297. package/src/prover/smt/table.ts +0 -8
  298. package/src/prover/tlapm/cache.ts +45 -40
  299. package/src/prover/tlapm/ocaml-marshal.ts +19 -21
  300. package/src/prover/tlapm/tlapm.ts +21 -20
  301. package/src/prover/verdict.ts +7 -2
  302. package/src/prover/zenon/check/check.ts +1 -11
  303. package/src/prover/zenon/check/definitions.ts +5 -15
  304. package/src/prover/zenon/check/equality.ts +0 -8
  305. package/src/prover/zenon/check/functions.ts +0 -4
  306. package/src/prover/zenon/check/keys.ts +0 -7
  307. package/src/prover/zenon/check/propositional.ts +0 -3
  308. package/src/prover/zenon/check/records.ts +1 -6
  309. package/src/prover/zenon/check/relations.ts +2 -14
  310. package/src/prover/zenon/check/rewrites.ts +2 -21
  311. package/src/prover/zenon/check/sets.ts +40 -61
  312. package/src/prover/zenon/check/terms.ts +1 -19
  313. package/src/prover/zenon/check/tla.ts +0 -6
  314. package/src/prover/zenon/decide.ts +0 -12
  315. package/src/prover/zenon/encode.ts +1 -8
  316. package/src/prover/zenon/eqrel.ts +2 -13
  317. package/src/prover/zenon/equality-rules.ts +0 -4
  318. package/src/prover/zenon/expr.ts +8 -26
  319. package/src/prover/zenon/index-table.ts +26 -57
  320. package/src/prover/zenon/isar-case.ts +9 -19
  321. package/src/prover/zenon/isar.ts +36 -64
  322. package/src/prover/zenon/limits.ts +0 -4
  323. package/src/prover/zenon/llproof.ts +2 -20
  324. package/src/prover/zenon/mltoll.ts +66 -104
  325. package/src/prover/zenon/node.ts +1 -11
  326. package/src/prover/zenon/ocaml.ts +1 -17
  327. package/src/prover/zenon/parse.ts +4 -12
  328. package/src/prover/zenon/phrase.ts +1 -11
  329. package/src/prover/zenon/proof.ts +0 -9
  330. package/src/prover/zenon/propositional-rules.ts +0 -5
  331. package/src/prover/zenon/rules.ts +2 -6
  332. package/src/prover/zenon/search.ts +5 -31
  333. package/src/prover/zenon/tla/functions.ts +59 -31
  334. package/src/prover/zenon/tla/llproof.ts +67 -76
  335. package/src/prover/zenon/tla/records.ts +57 -33
  336. package/src/prover/zenon/tla/rewrites.ts +12 -19
  337. package/src/prover/zenon/tla/sets.ts +83 -53
  338. package/src/prover/zenon/tla/terms.ts +0 -6
  339. package/src/prover/zenon/tla/tla.ts +66 -64
  340. package/src/randomization.ts +81 -35
  341. package/src/resolve.ts +67 -184
  342. package/src/runtime.ts +22 -22
  343. package/src/sany/builtins.ts +2 -5
  344. package/src/sany/generation.ts +394 -0
  345. package/src/sany/generator-def-entries.ts +210 -0
  346. package/src/sany/generator-definitions.ts +686 -0
  347. package/src/sany/generator-expressions.ts +1100 -0
  348. package/src/sany/generator-proofs.ts +662 -0
  349. package/src/sany/generator.ts +191 -2764
  350. package/src/sany/levels.ts +6 -34
  351. package/src/sany/lexer.ts +58 -77
  352. package/src/sany/linter.ts +1 -9
  353. package/src/sany/modules.ts +1 -5
  354. package/src/sany/nodes.ts +5 -43
  355. package/src/sany/parse-error.ts +39 -117
  356. package/src/sany/report.ts +32 -69
  357. package/src/sany/selectors.ts +49 -76
  358. package/src/sany/source.ts +1 -17
  359. package/src/sany/xml.ts +35 -117
  360. package/src/search.ts +541 -163
  361. package/src/simulate.ts +709 -0
  362. package/src/spec-description.ts +192 -100
  363. package/src/standard-definitions.ts +0 -4
  364. package/src/standard-modules.ts +264 -95
  365. package/src/state-graph.ts +52 -31
  366. package/src/subexpressions.ts +69 -52
  367. package/src/substitution-levels.ts +7 -7
  368. package/src/successors.ts +266 -99
  369. package/src/symmetry.ts +33 -25
  370. package/src/tableau.ts +27 -24
  371. package/src/tlc/fingerprint.ts +183 -67
  372. package/src/tlc/jar-data.ts +112 -6
  373. package/src/tlc/messages.ts +125 -54
  374. package/src/tlc/order.ts +39 -69
  375. package/src/tlc/random.ts +37 -49
  376. package/src/tlc/replay.ts +553 -228
  377. package/src/tlc/summary.ts +36 -47
  378. package/src/tlc/tlc-operators.ts +78 -44
  379. package/src/tlc/tlcext-operators.ts +139 -122
  380. package/src/tlc/trace-spec.ts +249 -0
  381. package/src/tlc/value-stream.ts +139 -0
  382. package/src/tlc/version.ts +1 -4
  383. package/src/transfer.ts +22 -25
  384. package/src/typescript/actions.ts +479 -0
  385. package/src/typescript/collections.ts +614 -0
  386. package/src/typescript/compile.ts +63 -0
  387. package/src/typescript/context.ts +94 -0
  388. package/src/typescript/emit.ts +121 -0
  389. package/src/typescript/expressions.ts +496 -0
  390. package/src/typescript/formula.ts +154 -0
  391. package/src/typescript/functions.ts +284 -0
  392. package/src/typescript/model.ts +162 -0
  393. package/src/typescript/names.ts +114 -0
  394. package/src/typescript/program.ts +48 -0
  395. package/src/typescript/properties.ts +139 -0
  396. package/src/typescript/scope.ts +112 -0
  397. package/src/typescript/steps.ts +167 -0
  398. package/src/typescript/types.ts +171 -0
  399. package/src/values.ts +832 -484
  400. package/src/worker.ts +7 -8
@@ -0,0 +1,614 @@
1
+ import ts from "@typescript/typescript6";
2
+ import {
3
+ type Context,
4
+ getCallee,
5
+ getSymbol,
6
+ isMethodCall,
7
+ type MethodCall,
8
+ share,
9
+ } from "./context";
10
+ import { TlaTypeScriptError } from "../errors";
11
+ import { translateExpression } from "./expressions";
12
+ import { wrap, wrapEquated } from "./formula";
13
+ import { translateBody } from "./functions";
14
+ import { bindNames, bindPatternInline, type Scope } from "./scope";
15
+ import { getKind, type Kind } from "./types";
16
+
17
+ interface Unordered {
18
+ set: string;
19
+ isMapped: boolean;
20
+ }
21
+
22
+ const SINGLE_USE_METHODS = new Set(["concat", "with", "filter"]);
23
+
24
+ interface Element {
25
+ variable: string;
26
+ scope: Scope;
27
+ }
28
+
29
+ interface Update {
30
+ (current: string, values: string[], context: Context): string;
31
+ }
32
+
33
+ const getCallback = (callback: ts.Expression, context: Context) => {
34
+ const callee = getCallee(callback, context);
35
+ if (callee?.body === undefined) throw new TlaTypeScriptError("Pass a function here", callback);
36
+ return { parameters: callee.parameters, body: callee.body };
37
+ };
38
+
39
+ const translateCallback = (callback: ts.Expression, scope: Scope, context: Context) =>
40
+ translateBody(getCallback(callback, context).body, scope, context);
41
+
42
+ const rejectIndex = (callback: ts.Expression, message: string, context: Context) => {
43
+ if (getCallback(callback, context).parameters[1] !== undefined) {
44
+ throw new TlaTypeScriptError(message, callback);
45
+ }
46
+ };
47
+
48
+ const bindElement = (callback: ts.Expression, scope: Scope, context: Context): Element => {
49
+ const parameter = getCallback(callback, context).parameters[0];
50
+ if (parameter === undefined) return { variable: context.names.getFresh("element"), scope };
51
+ if (!ts.isIdentifier(parameter.name)) {
52
+ const variable = context.names.getFresh("element");
53
+ return { variable, scope: bindPatternInline(parameter.name, variable, scope, context) };
54
+ }
55
+ const variable = context.names.getFresh(parameter.name.text);
56
+ const symbol = getSymbol(parameter.name, context.checker);
57
+ return { variable, scope: bindNames(scope, [{ name: variable, symbol }]) };
58
+ };
59
+
60
+ const bindIndexed = (
61
+ callback: ts.Expression,
62
+ element: string | undefined,
63
+ index: string,
64
+ scope: Scope,
65
+ context: Context,
66
+ ) => {
67
+ const parameters = getCallback(callback, context).parameters;
68
+ const withElement =
69
+ element === undefined || parameters[0] === undefined
70
+ ? scope
71
+ : bindPatternInline(parameters[0].name, element, scope, context);
72
+ return parameters[1] === undefined
73
+ ? withElement
74
+ : bindPatternInline(parameters[1].name, `(${index} - 1)`, withElement, context);
75
+ };
76
+
77
+ const getValues = (value: string, context: Context): Unordered => ({
78
+ set: share(value, "map", context, (map) => {
79
+ const key = context.names.getFresh("key");
80
+ return `{${map}[${key}] : ${key} \\in DOMAIN ${map}}`;
81
+ }),
82
+ isMapped: true,
83
+ });
84
+
85
+ const getEntries = (value: string, context: Context): Unordered => ({
86
+ set: share(value, "map", context, (map) => {
87
+ const key = context.names.getFresh("key");
88
+ return `{<<${key}, ${map}[${key}]>> : ${key} \\in DOMAIN ${map}}`;
89
+ }),
90
+ isMapped: false,
91
+ });
92
+
93
+ const getElements = (value: string, context: Context) =>
94
+ share(value, "sequence", context, (sequence) => {
95
+ const index = context.names.getFresh("index");
96
+ return `{${sequence}[${index}] : ${index} \\in DOMAIN ${sequence}}`;
97
+ });
98
+
99
+ const translateUnordered = (
100
+ node: ts.Expression,
101
+ scope: Scope,
102
+ context: Context,
103
+ ): Unordered | undefined => {
104
+ const translate = (inner: ts.Expression) => translateExpression(inner, scope, context);
105
+ if (ts.isParenthesizedExpression(node)) {
106
+ return translateUnordered(node.expression, scope, context);
107
+ }
108
+ if (
109
+ ts.isArrayLiteralExpression(node) &&
110
+ node.elements.length === 1 &&
111
+ ts.isSpreadElement(node.elements[0])
112
+ ) {
113
+ const spread = node.elements[0].expression;
114
+ const kind = getKind(spread, context);
115
+ if (kind === "set") return { set: translate(spread), isMapped: false };
116
+ if (kind === "map") return getEntries(translate(spread), context);
117
+ return translateUnordered(spread, scope, context);
118
+ }
119
+ if (!isMethodCall(node)) return undefined;
120
+ const receiver = node.expression.expression;
121
+ const method = node.expression.name.text;
122
+ if (ts.isIdentifier(receiver) && receiver.text === "Object") {
123
+ const record = translate(node.arguments[0]);
124
+ if (method === "keys") return { set: `DOMAIN ${wrap(record)}`, isMapped: false };
125
+ if (method === "values") return getValues(record, context);
126
+ if (method === "entries") return getEntries(record, context);
127
+ return undefined;
128
+ }
129
+ const kind = getKind(receiver, context);
130
+ if (kind === "set" && (method === "values" || method === "keys")) {
131
+ return { set: translate(receiver), isMapped: false };
132
+ }
133
+ if (kind === "set" && method === "entries") {
134
+ const element = context.names.getFresh("element");
135
+ return {
136
+ set: `{<<${element}, ${element}>> : ${element} \\in ${wrap(translate(receiver))}}`,
137
+ isMapped: false,
138
+ };
139
+ }
140
+ if (kind === "map" && method === "keys") {
141
+ return { set: `DOMAIN ${wrap(translate(receiver))}`, isMapped: false };
142
+ }
143
+ if (kind === "map" && method === "values") return getValues(translate(receiver), context);
144
+ if (kind === "map" && method === "entries") return getEntries(translate(receiver), context);
145
+ if (method === "toArray") return translateUnordered(receiver, scope, context);
146
+ if (method !== "filter" && method !== "map") return undefined;
147
+ const source = translateUnordered(receiver, scope, context);
148
+ if (source === undefined) return undefined;
149
+ const callback = node.arguments[0];
150
+ rejectIndex(callback, "Elements of a set have no index", context);
151
+ const element = bindElement(callback, scope, context);
152
+ const body = translateCallback(callback, element.scope, context);
153
+ return method === "filter"
154
+ ? { set: `{${element.variable} \\in ${wrap(source.set)} : ${body}}`, isMapped: source.isMapped }
155
+ : { set: `{${body} : ${element.variable} \\in ${wrap(source.set)}}`, isMapped: true };
156
+ };
157
+
158
+ export const translateSet = (node: ts.Expression, scope: Scope, context: Context) => {
159
+ const unordered = translateUnordered(node, scope, context);
160
+ if (unordered !== undefined) return unordered.set;
161
+ const kind = getKind(node, context);
162
+ const value = translateExpression(node, scope, context);
163
+ if (kind === "set") return value;
164
+ if (kind !== "sequence") throw new TlaTypeScriptError("Expected a Set or an array", node);
165
+ return getElements(value, context);
166
+ };
167
+
168
+ export const translateSize = (node: ts.Expression, scope: Scope, context: Context) => {
169
+ const unordered = translateUnordered(node, scope, context);
170
+ if (unordered?.isMapped) {
171
+ throw new TlaTypeScriptError(
172
+ "map() can merge equal elements, so count before mapping",
173
+ node.parent,
174
+ );
175
+ }
176
+ if (unordered !== undefined) return `Cardinality(${unordered.set})`;
177
+ const kind = getKind(node, context);
178
+ const value = translateExpression(node, scope, context);
179
+ if (kind === "sequence" || kind === "string") return `Len(${value})`;
180
+ if (kind === "set") return `Cardinality(${value})`;
181
+ if (kind === "map") return `Cardinality(DOMAIN ${wrap(value)})`;
182
+ return undefined;
183
+ };
184
+
185
+ export const translateFunctionConstructor = (
186
+ node: ts.Expression,
187
+ scope: Scope,
188
+ context: Context,
189
+ ) => {
190
+ if (!isMethodCall(node) || node.expression.name.text !== "map") return undefined;
191
+ const receiver = node.expression.expression;
192
+ const source =
193
+ translateUnordered(receiver, scope, context)?.set ??
194
+ (getKind(receiver, context) === "sequence"
195
+ ? getElements(translateExpression(receiver, scope, context), context)
196
+ : undefined);
197
+ const callback = node.arguments[0];
198
+ const parameter = getCallback(callback, context).parameters[0];
199
+ const body =
200
+ (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) &&
201
+ !ts.isBlock(callback.body)
202
+ ? callback.body
203
+ : undefined;
204
+ const pair = body !== undefined && ts.isParenthesizedExpression(body) ? body.expression : body;
205
+ const isKeyedByParameter =
206
+ pair !== undefined &&
207
+ ts.isArrayLiteralExpression(pair) &&
208
+ pair.elements.length === 2 &&
209
+ parameter !== undefined &&
210
+ ts.isIdentifier(parameter.name) &&
211
+ ts.isIdentifier(pair.elements[0]) &&
212
+ pair.elements[0].text === parameter.name.text;
213
+ if (source === undefined || !isKeyedByParameter) {
214
+ throw new TlaTypeScriptError(
215
+ "Build a Map or record from a set with set.values().map((key) => [key, value])",
216
+ node,
217
+ );
218
+ }
219
+ const element = bindElement(callback, scope, context);
220
+ const value = translateExpression(pair.elements[1], element.scope, context);
221
+ return `[${element.variable} \\in ${source} |-> ${value}]`;
222
+ };
223
+
224
+ export const translateArrayConstructor = (node: MethodCall, scope: Scope, context: Context) => {
225
+ const receiver = node.expression.expression;
226
+ const method = node.expression.name.text;
227
+ const translateLength = (length: ts.Expression) =>
228
+ wrap(translateExpression(length, scope, context));
229
+ const callback = node.arguments[1];
230
+ const options = node.arguments[0];
231
+ if (
232
+ ts.isIdentifier(receiver) &&
233
+ receiver.text === "Array" &&
234
+ method === "from" &&
235
+ node.arguments.length === 2 &&
236
+ ts.isObjectLiteralExpression(options)
237
+ ) {
238
+ const length = options.properties.find((property) => property.name?.getText() === "length");
239
+ if (length === undefined || !ts.isPropertyAssignment(length)) {
240
+ throw new TlaTypeScriptError("Array.from needs { length: n }", node);
241
+ }
242
+ const index = context.names.getFresh("index");
243
+ const inner = bindIndexed(callback, undefined, index, scope, context);
244
+ return `[${index} \\in 1..${translateLength(length.initializer)} |-> ${translateCallback(callback, inner, context)}]`;
245
+ }
246
+ if (method !== "fill" || node.arguments.length !== 1) return undefined;
247
+ const array =
248
+ ts.isNewExpression(receiver) || ts.isCallExpression(receiver) ? receiver : undefined;
249
+ const length =
250
+ array !== undefined &&
251
+ ts.isIdentifier(array.expression) &&
252
+ array.expression.text === "Array" &&
253
+ array.arguments?.length === 1
254
+ ? array.arguments[0]
255
+ : undefined;
256
+ if (length === undefined) return undefined;
257
+ const index = context.names.getFresh("index");
258
+ return `[${index} \\in 1..${translateLength(length)} |-> ${translateExpression(node.arguments[0], scope, context)}]`;
259
+ };
260
+
261
+ const translateFirstIndex = (
262
+ sequence: string,
263
+ callback: ts.Expression,
264
+ scope: Scope,
265
+ context: Context,
266
+ ) => {
267
+ const getTest = (index: string) =>
268
+ translateCallback(
269
+ callback,
270
+ bindIndexed(callback, `${wrap(sequence)}[${index}]`, index, scope, context),
271
+ context,
272
+ );
273
+ const index = context.names.getFresh("index");
274
+ const earlier = context.names.getFresh("earlier");
275
+ return {
276
+ exists: `\\E ${index} \\in DOMAIN ${wrap(sequence)} : ${getTest(index)}`,
277
+ first: `CHOOSE ${index} \\in DOMAIN ${wrap(sequence)} : ${wrap(getTest(index))} /\\ \\A ${earlier} \\in 1..(${index} - 1) : ~${wrap(getTest(earlier))}`,
278
+ };
279
+ };
280
+
281
+ const orUndefined = (exists: string, value: string, isDefined: boolean, context: Context) => {
282
+ if (isDefined) return value;
283
+ context.prelude.add("Undefined");
284
+ return `IF ${exists} THEN ${value} ELSE Undefined`;
285
+ };
286
+
287
+ const translateSequenceOperation = (
288
+ node: MethodCall,
289
+ sequence: string,
290
+ scope: Scope,
291
+ context: Context,
292
+ isDefined: boolean,
293
+ ) => {
294
+ const method = node.expression.name.text;
295
+ const translate = (inner: ts.Expression) => translateExpression(inner, scope, context);
296
+ const argument = node.arguments[0];
297
+ const wrapped = wrap(sequence);
298
+ const isNegative = (inner: ts.Expression): inner is ts.PrefixUnaryExpression =>
299
+ ts.isPrefixUnaryExpression(inner) && inner.operator === ts.SyntaxKind.MinusToken;
300
+ const getOffset = (inner: ts.Expression) =>
301
+ isNegative(inner) ? `Len(${sequence}) - ${wrap(translate(inner.operand))}` : translate(inner);
302
+ const translateEach = (format: (index: string, body: string) => string) => () => {
303
+ const index = context.names.getFresh("index");
304
+ const inner = bindIndexed(argument, `${wrapped}[${index}]`, index, scope, context);
305
+ return format(index, translateCallback(argument, inner, context));
306
+ };
307
+ const operations = new Map<string, () => string>([
308
+ [
309
+ "at",
310
+ () => {
311
+ const index = isNegative(argument)
312
+ ? `${getOffset(argument)} + 1`
313
+ : `${wrap(translate(argument))} + 1`;
314
+ return orUndefined(
315
+ `${index} \\in DOMAIN ${wrapped}`,
316
+ `${wrapped}[${index}]`,
317
+ isDefined,
318
+ context,
319
+ );
320
+ },
321
+ ],
322
+ [
323
+ "includes",
324
+ () => {
325
+ const index = context.names.getFresh("index");
326
+ return `\\E ${index} \\in DOMAIN ${wrapped} : ${wrapped}[${index}] = ${wrap(translate(argument))}`;
327
+ },
328
+ ],
329
+ [
330
+ "indexOf",
331
+ () =>
332
+ share(translate(argument), "value", context, (value) => {
333
+ const index = context.names.getFresh("index");
334
+ const earlier = context.names.getFresh("earlier");
335
+ const isFound = `${wrapped}[${index}] = ${value}`;
336
+ return `IF \\E ${index} \\in DOMAIN ${wrapped} : ${isFound} THEN (CHOOSE ${index} \\in DOMAIN ${wrapped} : ${isFound} /\\ \\A ${earlier} \\in 1..(${index} - 1) : ${wrapped}[${earlier}] # ${value}) - 1 ELSE -1`;
337
+ }),
338
+ ],
339
+ [
340
+ "slice",
341
+ () => {
342
+ const start = argument === undefined ? "0" : getOffset(argument);
343
+ const end =
344
+ node.arguments[1] === undefined ? undefined : wrap(getOffset(node.arguments[1]));
345
+ const last =
346
+ end === undefined
347
+ ? `Len(${sequence})`
348
+ : `IF ${end} < Len(${sequence}) THEN ${end} ELSE Len(${sequence})`;
349
+ const first = /^\d+$/.test(start) ? String(Number(start) + 1) : `${wrap(start)} + 1`;
350
+ return `SubSeq(${sequence}, ${first}, ${last})`;
351
+ },
352
+ ],
353
+ [
354
+ "concat",
355
+ () =>
356
+ [
357
+ sequence,
358
+ ...node.arguments.map((inner) =>
359
+ getKind(inner, context) === "sequence" ? translate(inner) : `<<${translate(inner)}>>`,
360
+ ),
361
+ ]
362
+ .map(wrap)
363
+ .join(" \\o "),
364
+ ],
365
+ [
366
+ "with",
367
+ () =>
368
+ `[${wrapped} EXCEPT ![${wrap(translate(argument))} + 1] = ${wrapEquated(translate(node.arguments[1]))}]`,
369
+ ],
370
+ [
371
+ "toReversed",
372
+ () => {
373
+ const index = context.names.getFresh("index");
374
+ return `[${index} \\in DOMAIN ${wrapped} |-> ${wrapped}[Len(${sequence}) - ${index} + 1]]`;
375
+ },
376
+ ],
377
+ ["map", translateEach((index, body) => `[${index} \\in DOMAIN ${wrapped} |-> ${body}]`)],
378
+ ["every", translateEach((index, body) => `\\A ${index} \\in DOMAIN ${wrapped} : ${body}`)],
379
+ ["some", translateEach((index, body) => `\\E ${index} \\in DOMAIN ${wrapped} : ${body}`)],
380
+ [
381
+ "filter",
382
+ () => {
383
+ rejectIndex(argument, "filter() can't take an index", context);
384
+ const element = bindElement(argument, scope, context);
385
+ return `SelectSeq(${sequence}, LAMBDA ${element.variable} : ${translateCallback(argument, element.scope, context)})`;
386
+ },
387
+ ],
388
+ [
389
+ "find",
390
+ () => {
391
+ const result = translateFirstIndex(sequence, argument, scope, context);
392
+ return orUndefined(result.exists, `${wrapped}[${result.first}]`, isDefined, context);
393
+ },
394
+ ],
395
+ [
396
+ "findIndex",
397
+ () => {
398
+ const result = translateFirstIndex(sequence, argument, scope, context);
399
+ return `IF ${result.exists} THEN (${result.first}) - 1 ELSE -1`;
400
+ },
401
+ ],
402
+ ]);
403
+ const operation = operations.get(method);
404
+ if (operation === undefined)
405
+ throw new TlaTypeScriptError(`Unsupported array method: ${method}`, node);
406
+ return operation();
407
+ };
408
+
409
+ const translateUnorderedMethod = (
410
+ node: MethodCall,
411
+ source: Unordered,
412
+ scope: Scope,
413
+ context: Context,
414
+ isDefined: boolean,
415
+ ) => {
416
+ const method = node.expression.name.text;
417
+ const argument = node.arguments[0];
418
+ if (method === "includes" || method === "has") {
419
+ return `${wrap(translateExpression(argument, scope, context))} \\in ${wrap(source.set)}`;
420
+ }
421
+ if (method !== "every" && method !== "some" && method !== "find") {
422
+ throw new TlaTypeScriptError(`Unsupported method on a set's elements: ${method}`, node);
423
+ }
424
+ rejectIndex(argument, "Elements of a set have no index", context);
425
+ const element = bindElement(argument, scope, context);
426
+ const body = translateCallback(argument, element.scope, context);
427
+ const binding = `${element.variable} \\in ${wrap(source.set)} : ${body}`;
428
+ if (method === "every") return `\\A ${binding}`;
429
+ if (method === "some") return `\\E ${binding}`;
430
+ return orUndefined(`\\E ${binding}`, `CHOOSE ${binding}`, isDefined, context);
431
+ };
432
+
433
+ const translateSetMethod = (node: MethodCall, scope: Scope, context: Context) => {
434
+ const method = node.expression.name.text;
435
+ const set = wrap(translateExpression(node.expression.expression, scope, context));
436
+ const other =
437
+ node.arguments[0] === undefined
438
+ ? ""
439
+ : wrap(translateExpression(node.arguments[0], scope, context));
440
+ const operations = new Map([
441
+ ["has", `${other} \\in ${set}`],
442
+ ["union", `${set} \\cup ${other}`],
443
+ ["intersection", `${set} \\cap ${other}`],
444
+ ["difference", `${set} \\ ${other}`],
445
+ ["symmetricDifference", `(${set} \\ ${other}) \\cup (${other} \\ ${set})`],
446
+ ["isSubsetOf", `${set} \\subseteq ${other}`],
447
+ ["isSupersetOf", `${other} \\subseteq ${set}`],
448
+ ["isDisjointFrom", `${set} \\cap ${other} = {}`],
449
+ ]);
450
+ const operation = operations.get(method);
451
+ if (operation === undefined)
452
+ throw new TlaTypeScriptError(`Unsupported Set method: ${method}`, node);
453
+ if (node.arguments[0] === undefined)
454
+ throw new TlaTypeScriptError(`Set method needs an argument: ${method}`, node);
455
+ return operation;
456
+ };
457
+
458
+ const translateMapMethod = (
459
+ node: MethodCall,
460
+ scope: Scope,
461
+ context: Context,
462
+ isDefined: boolean,
463
+ ) => {
464
+ const method = node.expression.name.text;
465
+ const map = wrap(translateExpression(node.expression.expression, scope, context));
466
+ const key =
467
+ node.arguments[0] === undefined
468
+ ? ""
469
+ : wrap(translateExpression(node.arguments[0], scope, context));
470
+ if (method !== "has" && method !== "get")
471
+ throw new TlaTypeScriptError(`Unsupported Map method: ${method}`, node);
472
+ if (node.arguments[0] === undefined)
473
+ throw new TlaTypeScriptError(`Map method needs a key: ${method}`, node);
474
+ if (method === "has") return `${key} \\in DOMAIN ${map}`;
475
+ if (isDefined) return `${map}[${key}]`;
476
+ return share(map, "map", context, (sharedMap) =>
477
+ share(key, "key", context, (sharedKey) =>
478
+ orUndefined(
479
+ `${sharedKey} \\in DOMAIN ${sharedMap}`,
480
+ `${sharedMap}[${sharedKey}]`,
481
+ isDefined,
482
+ context,
483
+ ),
484
+ ),
485
+ );
486
+ };
487
+
488
+ export const REMOVALS = {
489
+ pop: (current: string) => `SubSeq(${current}, 1, Len(${current}) - 1)`,
490
+ shift: (current: string) => `Tail(${current})`,
491
+ };
492
+
493
+ const UPDATES = new Map<Kind, Map<string, Update>>([
494
+ [
495
+ "sequence",
496
+ new Map<string, Update>([
497
+ [
498
+ "push",
499
+ (current, values) =>
500
+ values.length === 1
501
+ ? `Append(${current}, ${values[0]})`
502
+ : `${wrap(current)} \\o <<${values.join(", ")}>>`,
503
+ ],
504
+ ["unshift", (current, values) => `<<${values.join(", ")}>> \\o ${wrap(current)}`],
505
+ ["pop", REMOVALS.pop],
506
+ ["shift", REMOVALS.shift],
507
+ ]),
508
+ ],
509
+ [
510
+ "set",
511
+ new Map<string, Update>([
512
+ ["add", (current, values) => `${wrap(current)} \\cup {${values[0]}}`],
513
+ ["delete", (current, values) => `${wrap(current)} \\ {${values[0]}}`],
514
+ ["clear", () => "{}"],
515
+ ]),
516
+ ],
517
+ [
518
+ "map",
519
+ new Map<string, Update>([
520
+ ["set", (current, values) => `(${values[0]} :> ${values[1]}) @@ ${wrap(current)}`],
521
+ [
522
+ "delete",
523
+ (current, values, context) => {
524
+ const key = context.names.getFresh("key");
525
+ return `[${key} \\in DOMAIN ${wrap(current)} \\ {${values[0]}} |-> ${wrap(current)}[${key}]]`;
526
+ },
527
+ ],
528
+ ["clear", () => "<<>>"],
529
+ ]),
530
+ ],
531
+ ]);
532
+
533
+ export const MUTATING_METHODS = new Set(
534
+ [...UPDATES.values()].flatMap((updates) => [...updates.keys()]),
535
+ );
536
+
537
+ export const getUpdatedValue = (
538
+ current: string,
539
+ kind: Kind,
540
+ node: MethodCall,
541
+ scope: Scope,
542
+ context: Context,
543
+ ) => {
544
+ const values = node.arguments.map((argument) => translateExpression(argument, scope, context));
545
+ return UPDATES.get(kind)?.get(node.expression.name.text)?.(current, values, context);
546
+ };
547
+
548
+ export const translateMethod = (
549
+ node: MethodCall,
550
+ scope: Scope,
551
+ context: Context,
552
+ isDefined: boolean,
553
+ ) => {
554
+ const receiver = node.expression.expression;
555
+ const unordered = translateUnordered(receiver, scope, context);
556
+ if (unordered !== undefined) {
557
+ return translateUnorderedMethod(node, unordered, scope, context, isDefined);
558
+ }
559
+ const isCopy =
560
+ ts.isNewExpression(receiver) &&
561
+ receiver.arguments?.length === 1 &&
562
+ ts.isIdentifier(receiver.expression) &&
563
+ (receiver.expression.text === "Set" || receiver.expression.text === "Map");
564
+ const kind = getKind(receiver, context);
565
+ const updated = isCopy
566
+ ? getUpdatedValue(translateExpression(receiver, scope, context), kind, node, scope, context)
567
+ : undefined;
568
+ if (updated !== undefined) return updated;
569
+ if (kind === "sequence") {
570
+ const method = node.expression.name.text;
571
+ const sequence = translateExpression(receiver, scope, context);
572
+ const translateWith = (shared: string) =>
573
+ translateSequenceOperation(node, shared, scope, context, isDefined);
574
+ return SINGLE_USE_METHODS.has(method)
575
+ ? translateWith(sequence)
576
+ : share(sequence, "sequence", context, translateWith);
577
+ }
578
+ if (kind === "set") return translateSetMethod(node, scope, context);
579
+ if (kind === "map") return translateMapMethod(node, scope, context, isDefined);
580
+ throw new TlaTypeScriptError(`Unsupported call: ${node.expression.getText()}`, node);
581
+ };
582
+
583
+ export const translateNew = (node: ts.NewExpression, scope: Scope, context: Context) => {
584
+ const constructor = node.expression.getText();
585
+ const argument = node.arguments?.[0];
586
+ if (constructor === "Set") {
587
+ if (argument === undefined) return "{}";
588
+ if (ts.isArrayLiteralExpression(argument) && !argument.elements.some(ts.isSpreadElement)) {
589
+ return `{${argument.elements.map((element) => translateExpression(element, scope, context)).join(", ")}}`;
590
+ }
591
+ return translateSet(argument, scope, context);
592
+ }
593
+ if (constructor !== "Map") {
594
+ throw new TlaTypeScriptError(`Unsupported constructor: new ${constructor}`, node);
595
+ }
596
+ if (argument === undefined) return "<<>>";
597
+ if (ts.isArrayLiteralExpression(argument)) {
598
+ if (argument.elements.length === 0) return "<<>>";
599
+ return argument.elements
600
+ .toReversed()
601
+ .map((entry) => {
602
+ if (!ts.isArrayLiteralExpression(entry) || entry.elements.length !== 2) {
603
+ throw new TlaTypeScriptError("Write each Map entry as [key, value]", entry);
604
+ }
605
+ return `(${translateExpression(entry.elements[0], scope, context)} :> ${translateExpression(entry.elements[1], scope, context)})`;
606
+ })
607
+ .join(" @@ ");
608
+ }
609
+ if (getKind(argument, context) === "map") return translateExpression(argument, scope, context);
610
+ const map = translateFunctionConstructor(argument, scope, context);
611
+ if (map === undefined)
612
+ throw new TlaTypeScriptError(`Unsupported constructor: new ${constructor}`, node);
613
+ return map;
614
+ };
@@ -0,0 +1,63 @@
1
+ import { basename } from "node:path";
2
+ import ts from "@typescript/typescript6";
3
+ import { writesState } from "./actions";
4
+ import { type Context, createContext } from "./context";
5
+ import { type CompiledSpec, createSections, emit, type Sections } from "./emit";
6
+ import { TlaTypeScriptError } from "../errors";
7
+ import { indent, wrapEquated } from "./formula";
8
+ import { translateBody } from "./functions";
9
+ import { type Exported, type Model, readModel, type Variable } from "./model";
10
+ import { createProgram } from "./program";
11
+ import { translateInvariant, translateProperty, VALUE_TAGS } from "./properties";
12
+ import { createStateScope } from "./scope";
13
+ import { translateStep } from "./steps";
14
+ import { getDomain } from "./types";
15
+
16
+ const translateInitial = (variable: Variable, context: Context) => {
17
+ const initializer = variable.declaration.initializer;
18
+ if (initializer === undefined) {
19
+ const type = context.checker.getTypeAtLocation(variable.declaration.name);
20
+ return `${variable.name} \\in ${getDomain(type, variable.declaration, context)}`;
21
+ }
22
+ const value = translateBody(initializer, createStateScope(context), context);
23
+ return `${variable.name} = ${indent(wrapEquated(value), " ")}`;
24
+ };
25
+
26
+ const translateExported = (
27
+ definition: Exported,
28
+ model: Model,
29
+ sections: Sections,
30
+ context: Context,
31
+ ) => {
32
+ const tag = [...definition.tags.keys()].find((candidate) => VALUE_TAGS.has(candidate));
33
+ if (tag !== undefined) return translateProperty(definition, tag, model, sections, context);
34
+ const returnType = context.checker.getSignatureFromDeclaration(definition.node)?.getReturnType();
35
+ if (
36
+ writesState(definition.body, context) ||
37
+ returnType === undefined ||
38
+ (returnType.flags & (ts.TypeFlags.Void | ts.TypeFlags.Undefined)) !== 0
39
+ ) {
40
+ return translateStep(definition, sections, context);
41
+ }
42
+ if (!(returnType.flags & ts.TypeFlags.BooleanLike)) {
43
+ throw new TlaTypeScriptError(
44
+ "An exported function that returns a value must return a boolean, or be tagged, such as @view",
45
+ definition.node,
46
+ );
47
+ }
48
+ return translateInvariant(definition, sections, context);
49
+ };
50
+
51
+ export const compile = (source: string, fileName = "spec.ts"): CompiledSpec => {
52
+ const program = createProgram(source, fileName.replaceAll("\\", "/"));
53
+ const context = createContext(program.checker);
54
+ const model = readModel(program.sourceFile, context);
55
+ const sections = createSections();
56
+ sections.init.push(...model.variables.map((variable) => translateInitial(variable, context)));
57
+ for (const definition of model.exported) translateExported(definition, model, sections, context);
58
+ const moduleName = basename(fileName, ".ts")
59
+ .split(/[^A-Za-z0-9]+/)
60
+ .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
61
+ .join("");
62
+ return emit(moduleName, model, sections, context);
63
+ };