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
@@ -0,0 +1,600 @@
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 translateSequenceOperation = (
282
+ node: MethodCall,
283
+ sequence: string,
284
+ scope: Scope,
285
+ context: Context,
286
+ isDefined: boolean,
287
+ ) => {
288
+ const method = node.expression.name.text;
289
+ const translate = (inner: ts.Expression) => translateExpression(inner, scope, context);
290
+ const argument = node.arguments[0];
291
+ const wrapped = wrap(sequence);
292
+ const isNegative = (inner: ts.Expression): inner is ts.PrefixUnaryExpression =>
293
+ ts.isPrefixUnaryExpression(inner) && inner.operator === ts.SyntaxKind.MinusToken;
294
+ const getOffset = (inner: ts.Expression) =>
295
+ isNegative(inner) ? `Len(${sequence}) - ${wrap(translate(inner.operand))}` : translate(inner);
296
+ const orUndefined = (exists: string, value: string) => {
297
+ if (isDefined) return value;
298
+ context.prelude.add("Undefined");
299
+ return `IF ${exists} THEN ${value} ELSE Undefined`;
300
+ };
301
+ const translateEach = (format: (index: string, body: string) => string) => () => {
302
+ const index = context.names.getFresh("index");
303
+ const inner = bindIndexed(argument, `${wrapped}[${index}]`, index, scope, context);
304
+ return format(index, translateCallback(argument, inner, context));
305
+ };
306
+ const operations = new Map<string, () => string>([
307
+ [
308
+ "at",
309
+ () => {
310
+ const index = isNegative(argument)
311
+ ? `${getOffset(argument)} + 1`
312
+ : `${wrap(translate(argument))} + 1`;
313
+ return orUndefined(`${index} \\in DOMAIN ${wrapped}`, `${wrapped}[${index}]`);
314
+ },
315
+ ],
316
+ [
317
+ "includes",
318
+ () => {
319
+ const index = context.names.getFresh("index");
320
+ return `\\E ${index} \\in DOMAIN ${wrapped} : ${wrapped}[${index}] = ${wrap(translate(argument))}`;
321
+ },
322
+ ],
323
+ [
324
+ "indexOf",
325
+ () =>
326
+ share(translate(argument), "value", context, (value) => {
327
+ const index = context.names.getFresh("index");
328
+ const earlier = context.names.getFresh("earlier");
329
+ const isFound = `${wrapped}[${index}] = ${value}`;
330
+ 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`;
331
+ }),
332
+ ],
333
+ [
334
+ "slice",
335
+ () => {
336
+ const start = argument === undefined ? "0" : getOffset(argument);
337
+ const end =
338
+ node.arguments[1] === undefined ? undefined : wrap(getOffset(node.arguments[1]));
339
+ const last =
340
+ end === undefined
341
+ ? `Len(${sequence})`
342
+ : `IF ${end} < Len(${sequence}) THEN ${end} ELSE Len(${sequence})`;
343
+ const first = /^\d+$/.test(start) ? String(Number(start) + 1) : `${wrap(start)} + 1`;
344
+ return `SubSeq(${sequence}, ${first}, ${last})`;
345
+ },
346
+ ],
347
+ [
348
+ "concat",
349
+ () =>
350
+ [
351
+ sequence,
352
+ ...node.arguments.map((inner) =>
353
+ getKind(inner, context) === "sequence" ? translate(inner) : `<<${translate(inner)}>>`,
354
+ ),
355
+ ]
356
+ .map(wrap)
357
+ .join(" \\o "),
358
+ ],
359
+ [
360
+ "with",
361
+ () =>
362
+ `[${wrapped} EXCEPT ![${wrap(translate(argument))} + 1] = ${wrapEquated(translate(node.arguments[1]))}]`,
363
+ ],
364
+ [
365
+ "toReversed",
366
+ () => {
367
+ const index = context.names.getFresh("index");
368
+ return `[${index} \\in DOMAIN ${wrapped} |-> ${wrapped}[Len(${sequence}) - ${index} + 1]]`;
369
+ },
370
+ ],
371
+ ["map", translateEach((index, body) => `[${index} \\in DOMAIN ${wrapped} |-> ${body}]`)],
372
+ ["every", translateEach((index, body) => `\\A ${index} \\in DOMAIN ${wrapped} : ${body}`)],
373
+ ["some", translateEach((index, body) => `\\E ${index} \\in DOMAIN ${wrapped} : ${body}`)],
374
+ [
375
+ "filter",
376
+ () => {
377
+ rejectIndex(argument, "filter() can't take an index", context);
378
+ const element = bindElement(argument, scope, context);
379
+ return `SelectSeq(${sequence}, LAMBDA ${element.variable} : ${translateCallback(argument, element.scope, context)})`;
380
+ },
381
+ ],
382
+ [
383
+ "find",
384
+ () => {
385
+ const result = translateFirstIndex(sequence, argument, scope, context);
386
+ return orUndefined(result.exists, `${wrapped}[${result.first}]`);
387
+ },
388
+ ],
389
+ [
390
+ "findIndex",
391
+ () => {
392
+ const result = translateFirstIndex(sequence, argument, scope, context);
393
+ return `IF ${result.exists} THEN (${result.first}) - 1 ELSE -1`;
394
+ },
395
+ ],
396
+ ]);
397
+ const operation = operations.get(method);
398
+ if (operation === undefined)
399
+ throw new TlaTypeScriptError(`Unsupported array method: ${method}`, node);
400
+ return operation();
401
+ };
402
+
403
+ const translateUnorderedMethod = (
404
+ node: MethodCall,
405
+ source: Unordered,
406
+ scope: Scope,
407
+ context: Context,
408
+ isDefined: boolean,
409
+ ) => {
410
+ const method = node.expression.name.text;
411
+ const argument = node.arguments[0];
412
+ if (method === "includes" || method === "has") {
413
+ return `${wrap(translateExpression(argument, scope, context))} \\in ${wrap(source.set)}`;
414
+ }
415
+ if (method !== "every" && method !== "some" && method !== "find") {
416
+ throw new TlaTypeScriptError(`Unsupported method on a set's elements: ${method}`, node);
417
+ }
418
+ rejectIndex(argument, "Elements of a set have no index", context);
419
+ const element = bindElement(argument, scope, context);
420
+ const body = translateCallback(argument, element.scope, context);
421
+ const binding = `${element.variable} \\in ${wrap(source.set)} : ${body}`;
422
+ if (method === "every") return `\\A ${binding}`;
423
+ if (method === "some") return `\\E ${binding}`;
424
+ if (isDefined) return `CHOOSE ${binding}`;
425
+ context.prelude.add("Undefined");
426
+ return `IF \\E ${binding} THEN CHOOSE ${binding} ELSE Undefined`;
427
+ };
428
+
429
+ const translateSetMethod = (node: MethodCall, scope: Scope, context: Context) => {
430
+ const method = node.expression.name.text;
431
+ const set = wrap(translateExpression(node.expression.expression, scope, context));
432
+ const other =
433
+ node.arguments[0] === undefined
434
+ ? ""
435
+ : wrap(translateExpression(node.arguments[0], scope, context));
436
+ const operations = new Map([
437
+ ["has", `${other} \\in ${set}`],
438
+ ["union", `${set} \\cup ${other}`],
439
+ ["intersection", `${set} \\cap ${other}`],
440
+ ["difference", `${set} \\ ${other}`],
441
+ ["symmetricDifference", `(${set} \\ ${other}) \\cup (${other} \\ ${set})`],
442
+ ["isSubsetOf", `${set} \\subseteq ${other}`],
443
+ ["isSupersetOf", `${other} \\subseteq ${set}`],
444
+ ["isDisjointFrom", `${set} \\cap ${other} = {}`],
445
+ ]);
446
+ const operation = operations.get(method);
447
+ if (operation === undefined)
448
+ throw new TlaTypeScriptError(`Unsupported Set method: ${method}`, node);
449
+ return operation;
450
+ };
451
+
452
+ const translateMapMethod = (
453
+ node: MethodCall,
454
+ scope: Scope,
455
+ context: Context,
456
+ isDefined: boolean,
457
+ ) => {
458
+ const method = node.expression.name.text;
459
+ const map = wrap(translateExpression(node.expression.expression, scope, context));
460
+ const key =
461
+ node.arguments[0] === undefined
462
+ ? ""
463
+ : wrap(translateExpression(node.arguments[0], scope, context));
464
+ if (method === "has") return `${key} \\in DOMAIN ${map}`;
465
+ if (method !== "get") throw new TlaTypeScriptError(`Unsupported Map method: ${method}`, node);
466
+ if (isDefined) return `${map}[${key}]`;
467
+ context.prelude.add("Undefined");
468
+ return share(map, "map", context, (sharedMap) =>
469
+ share(
470
+ key,
471
+ "key",
472
+ context,
473
+ (sharedKey) =>
474
+ `IF ${sharedKey} \\in DOMAIN ${sharedMap} THEN ${sharedMap}[${sharedKey}] ELSE Undefined`,
475
+ ),
476
+ );
477
+ };
478
+
479
+ const UPDATES = new Map<Kind, Map<string, Update>>([
480
+ [
481
+ "sequence",
482
+ new Map<string, Update>([
483
+ [
484
+ "push",
485
+ (current, values) =>
486
+ values.length === 1
487
+ ? `Append(${current}, ${values[0]})`
488
+ : `${wrap(current)} \\o <<${values.join(", ")}>>`,
489
+ ],
490
+ ["unshift", (current, values) => `<<${values.join(", ")}>> \\o ${wrap(current)}`],
491
+ ["pop", (current) => `SubSeq(${current}, 1, Len(${current}) - 1)`],
492
+ ["shift", (current) => `Tail(${current})`],
493
+ ]),
494
+ ],
495
+ [
496
+ "set",
497
+ new Map<string, Update>([
498
+ ["add", (current, values) => `${wrap(current)} \\cup {${values[0]}}`],
499
+ ["delete", (current, values) => `${wrap(current)} \\ {${values[0]}}`],
500
+ ["clear", () => "{}"],
501
+ ]),
502
+ ],
503
+ [
504
+ "map",
505
+ new Map<string, Update>([
506
+ ["set", (current, values) => `(${values[0]} :> ${values[1]}) @@ ${wrap(current)}`],
507
+ [
508
+ "delete",
509
+ (current, values, context) => {
510
+ const key = context.names.getFresh("key");
511
+ return `[${key} \\in DOMAIN ${wrap(current)} \\ {${values[0]}} |-> ${wrap(current)}[${key}]]`;
512
+ },
513
+ ],
514
+ ["clear", () => "<<>>"],
515
+ ]),
516
+ ],
517
+ ]);
518
+
519
+ export const MUTATING_METHODS = new Set(
520
+ [...UPDATES.values()].flatMap((updates) => [...updates.keys()]),
521
+ );
522
+
523
+ export const getUpdatedValue = (
524
+ current: string,
525
+ kind: Kind,
526
+ node: MethodCall,
527
+ scope: Scope,
528
+ context: Context,
529
+ ) => {
530
+ const values = node.arguments.map((argument) => translateExpression(argument, scope, context));
531
+ return UPDATES.get(kind)?.get(node.expression.name.text)?.(current, values, context);
532
+ };
533
+
534
+ export const translateMethod = (
535
+ node: MethodCall,
536
+ scope: Scope,
537
+ context: Context,
538
+ isDefined: boolean,
539
+ ) => {
540
+ const receiver = node.expression.expression;
541
+ const unordered = translateUnordered(receiver, scope, context);
542
+ if (unordered !== undefined) {
543
+ return translateUnorderedMethod(node, unordered, scope, context, isDefined);
544
+ }
545
+ const isCopy =
546
+ ts.isNewExpression(receiver) &&
547
+ receiver.arguments?.length === 1 &&
548
+ ts.isIdentifier(receiver.expression) &&
549
+ (receiver.expression.text === "Set" || receiver.expression.text === "Map");
550
+ const kind = getKind(receiver, context);
551
+ const updated = isCopy
552
+ ? getUpdatedValue(translateExpression(receiver, scope, context), kind, node, scope, context)
553
+ : undefined;
554
+ if (updated !== undefined) return updated;
555
+ if (kind === "sequence") {
556
+ const method = node.expression.name.text;
557
+ const sequence = translateExpression(receiver, scope, context);
558
+ const translateWith = (shared: string) =>
559
+ translateSequenceOperation(node, shared, scope, context, isDefined);
560
+ return SINGLE_USE_METHODS.has(method)
561
+ ? translateWith(sequence)
562
+ : share(sequence, "sequence", context, translateWith);
563
+ }
564
+ if (kind === "set") return translateSetMethod(node, scope, context);
565
+ if (kind === "map") return translateMapMethod(node, scope, context, isDefined);
566
+ throw new TlaTypeScriptError(`Unsupported call: ${node.expression.getText()}`, node);
567
+ };
568
+
569
+ export const translateNew = (node: ts.NewExpression, scope: Scope, context: Context) => {
570
+ const constructor = node.expression.getText();
571
+ const argument = node.arguments?.[0];
572
+ if (constructor === "Set") {
573
+ if (argument === undefined) return "{}";
574
+ if (ts.isArrayLiteralExpression(argument) && !argument.elements.some(ts.isSpreadElement)) {
575
+ return `{${argument.elements.map((element) => translateExpression(element, scope, context)).join(", ")}}`;
576
+ }
577
+ return translateSet(argument, scope, context);
578
+ }
579
+ if (constructor !== "Map") {
580
+ throw new TlaTypeScriptError(`Unsupported constructor: new ${constructor}`, node);
581
+ }
582
+ if (argument === undefined) return "<<>>";
583
+ if (ts.isArrayLiteralExpression(argument)) {
584
+ if (argument.elements.length === 0) return "<<>>";
585
+ return argument.elements
586
+ .toReversed()
587
+ .map((entry) => {
588
+ if (!ts.isArrayLiteralExpression(entry) || entry.elements.length !== 2) {
589
+ throw new TlaTypeScriptError("Write each Map entry as [key, value]", entry);
590
+ }
591
+ return `(${translateExpression(entry.elements[0], scope, context)} :> ${translateExpression(entry.elements[1], scope, context)})`;
592
+ })
593
+ .join(" @@ ");
594
+ }
595
+ if (getKind(argument, context) === "map") return translateExpression(argument, scope, context);
596
+ const map = translateFunctionConstructor(argument, scope, context);
597
+ if (map === undefined)
598
+ throw new TlaTypeScriptError(`Unsupported constructor: new ${constructor}`, node);
599
+ return map;
600
+ };
@@ -0,0 +1,65 @@
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
+ if (writesState(definition.body, context)) {
35
+ return translateStep(definition, sections, context);
36
+ }
37
+ const returnType = context.checker.getSignatureFromDeclaration(definition.node)?.getReturnType();
38
+ if (
39
+ returnType === undefined ||
40
+ (returnType.flags & (ts.TypeFlags.Void | ts.TypeFlags.Undefined)) !== 0
41
+ ) {
42
+ return translateStep(definition, sections, context);
43
+ }
44
+ if (!(returnType.flags & ts.TypeFlags.BooleanLike)) {
45
+ throw new TlaTypeScriptError(
46
+ "An exported function that returns a value must return a boolean, or be tagged, such as @view",
47
+ definition.node,
48
+ );
49
+ }
50
+ return translateInvariant(definition, sections, context);
51
+ };
52
+
53
+ export const compile = (source: string, fileName = "spec.ts"): CompiledSpec => {
54
+ const program = createProgram(source, fileName.replaceAll("\\", "/"));
55
+ const context = createContext(program.checker);
56
+ const model = readModel(program.sourceFile, context);
57
+ const sections = createSections();
58
+ sections.init.push(...model.variables.map((variable) => translateInitial(variable, context)));
59
+ for (const definition of model.exported) translateExported(definition, model, sections, context);
60
+ const moduleName = basename(fileName, ".ts")
61
+ .split(/[^A-Za-z0-9]+/)
62
+ .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
63
+ .join("");
64
+ return emit(moduleName, model, sections, context);
65
+ };