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,496 @@
1
+ import ts from "@typescript/typescript6";
2
+ import {
3
+ translateArrayConstructor,
4
+ translateFunctionConstructor,
5
+ translateMethod,
6
+ translateNew,
7
+ translateSet,
8
+ translateSize,
9
+ } from "./collections";
10
+ import {
11
+ type Context,
12
+ getFunction,
13
+ getSymbol,
14
+ getTopLevelDeclaration,
15
+ isMethodCall,
16
+ share,
17
+ translateString,
18
+ } from "./context";
19
+ import { TlaTypeScriptError } from "../errors";
20
+ import { wrap, wrapEquated } from "./formula";
21
+ import { getDefinition, translateHelperCall, translateLocalCall } from "./functions";
22
+ import type { Scope } from "./scope";
23
+ import { getKind, isBooleanLike, isNumericKey } from "./types";
24
+
25
+ interface Field {
26
+ key: string;
27
+ value: string;
28
+ }
29
+
30
+ const BINARY_OPERATORS = new Map([
31
+ [ts.SyntaxKind.MinusToken, "-"],
32
+ [ts.SyntaxKind.AsteriskToken, "*"],
33
+ [ts.SyntaxKind.AsteriskAsteriskToken, "^"],
34
+ [ts.SyntaxKind.EqualsEqualsEqualsToken, "="],
35
+ [ts.SyntaxKind.ExclamationEqualsEqualsToken, "#"],
36
+ [ts.SyntaxKind.LessThanToken, "<"],
37
+ [ts.SyntaxKind.LessThanEqualsToken, "<="],
38
+ [ts.SyntaxKind.GreaterThanToken, ">"],
39
+ [ts.SyntaxKind.GreaterThanEqualsToken, ">="],
40
+ ]);
41
+
42
+ const ORDERING_OPERATORS = new Set([
43
+ ts.SyntaxKind.LessThanToken,
44
+ ts.SyntaxKind.LessThanEqualsToken,
45
+ ts.SyntaxKind.GreaterThanToken,
46
+ ts.SyntaxKind.GreaterThanEqualsToken,
47
+ ]);
48
+
49
+ const LOGICAL_OPERATORS = new Map([
50
+ [ts.SyntaxKind.AmpersandAmpersandToken, "/\\"],
51
+ [ts.SyntaxKind.BarBarToken, "\\/"],
52
+ ]);
53
+
54
+ export const translateKey = (node: ts.ElementAccessExpression, scope: Scope, context: Context) => {
55
+ const key = node.argumentExpression;
56
+ if (getKind(node.expression, context) !== "sequence") {
57
+ return translateExpression(key, scope, context);
58
+ }
59
+ return ts.isNumericLiteral(key)
60
+ ? String(Number(key.text) + 1)
61
+ : `${wrap(translateExpression(key, scope, context))} + 1`;
62
+ };
63
+
64
+ const translateArrayLiteral = (node: ts.ArrayLiteralExpression, scope: Scope, context: Context) => {
65
+ const parts = node.elements.reduce<(string | string[])[]>((result, element) => {
66
+ if (!ts.isSpreadElement(element)) {
67
+ const value = translateExpression(element, scope, context);
68
+ const last = result.at(-1);
69
+ return Array.isArray(last)
70
+ ? [...result.slice(0, -1), [...last, value]]
71
+ : [...result, [value]];
72
+ }
73
+ if (getKind(element.expression, context) !== "sequence") {
74
+ throw new TlaTypeScriptError(
75
+ "Sets have no order, so spread one only into every(), some(), filter(), map(), or find()",
76
+ element,
77
+ );
78
+ }
79
+ return [...result, translateExpression(element.expression, scope, context)];
80
+ }, []);
81
+ const sequences = parts.map((part) => (Array.isArray(part) ? `<<${part.join(", ")}>>` : part));
82
+ if (sequences.length === 0) return "<<>>";
83
+ return sequences.length === 1 ? sequences[0] : sequences.map(wrap).join(" \\o ");
84
+ };
85
+
86
+ const getField = (key: string) => (isNumericKey(key) ? `[${key}]` : `.${key}`);
87
+
88
+ const formatRecord = (fields: Field[]) =>
89
+ fields.every((field) => isNumericKey(field.key))
90
+ ? fields.map((field) => `(${field.key} :> ${field.value})`).join(" @@ ")
91
+ : `[${fields.map((field) => `${field.key} |-> ${field.value}`).join(", ")}]`;
92
+
93
+ const translateObjectLiteral = (
94
+ node: ts.ObjectLiteralExpression,
95
+ scope: Scope,
96
+ context: Context,
97
+ ) => {
98
+ const checker = context.checker;
99
+ const getKey = (property: ts.ObjectLiteralElementLike) =>
100
+ property.name === undefined || ts.isComputedPropertyName(property.name)
101
+ ? undefined
102
+ : property.name.getText().replace(/^["']|["']$/g, "");
103
+ const getValue = (property: ts.ObjectLiteralElementLike) => {
104
+ if (ts.isPropertyAssignment(property)) {
105
+ return translateExpression(property.initializer, scope, context);
106
+ }
107
+ if (ts.isShorthandPropertyAssignment(property)) {
108
+ return translateExpression(property.name, scope, context);
109
+ }
110
+ throw new TlaTypeScriptError("Unsupported object member", property);
111
+ };
112
+ const spreads = node.properties.filter(ts.isSpreadAssignment);
113
+ if (spreads.length === 0) {
114
+ if (node.properties.length === 0) {
115
+ throw new TlaTypeScriptError("TLA+ has no empty record, so use a Map", node);
116
+ }
117
+ return formatRecord(
118
+ node.properties.map((property) => {
119
+ const key = getKey(property);
120
+ if (key === undefined) {
121
+ throw new TlaTypeScriptError("Computed keys need a spread base", property);
122
+ }
123
+ return { key, value: getValue(property) };
124
+ }),
125
+ );
126
+ }
127
+ const base = node.properties[0];
128
+ const updates = node.properties.slice(1);
129
+ if (ts.isSpreadAssignment(base) && spreads.length === 1) {
130
+ const baseType = checker.getTypeAtLocation(base.expression);
131
+ const value = translateExpression(base.expression, scope, context);
132
+ if (updates.length === 0) return value;
133
+ const isUpdate = updates.every((property) => {
134
+ const key = getKey(property);
135
+ return key === undefined || baseType.getProperty(key) !== undefined;
136
+ });
137
+ if (isUpdate) {
138
+ const changes = updates.map((property) => {
139
+ const key = getKey(property);
140
+ if (key !== undefined) return `!${getField(key)} = ${wrapEquated(getValue(property))}`;
141
+ if (property.name === undefined || !ts.isComputedPropertyName(property.name)) {
142
+ throw new TlaTypeScriptError("Unsupported object member", property);
143
+ }
144
+ return `![${translateExpression(property.name.expression, scope, context)}] = ${wrapEquated(getValue(property))}`;
145
+ });
146
+ return `[${wrap(value)} EXCEPT ${changes.join(", ")}]`;
147
+ }
148
+ }
149
+ return formatRecord(
150
+ checker
151
+ .getTypeAtLocation(node)
152
+ .getProperties()
153
+ .map((property) => {
154
+ const key = property.name;
155
+ const member = node.properties.findLast((candidate) =>
156
+ ts.isSpreadAssignment(candidate)
157
+ ? checker.getTypeAtLocation(candidate.expression).getProperty(key) !== undefined
158
+ : getKey(candidate) === key,
159
+ );
160
+ if (
161
+ member === undefined ||
162
+ (!ts.isSpreadAssignment(member) && getKey(member) === undefined)
163
+ ) {
164
+ throw new TlaTypeScriptError(`Can't tell which value ${key} takes`, node);
165
+ }
166
+ return {
167
+ key,
168
+ value: ts.isSpreadAssignment(member)
169
+ ? `${wrap(translateExpression(member.expression, scope, context))}${getField(key)}`
170
+ : getValue(member),
171
+ };
172
+ }),
173
+ );
174
+ };
175
+
176
+ const translateMath = (node: ts.CallExpression, method: string, scope: Scope, context: Context) => {
177
+ const translate = (inner: ts.Expression) => wrap(translateExpression(inner, scope, context));
178
+ const argument = node.arguments[0];
179
+ if ((method === "floor" || method === "trunc") && node.arguments.length === 1) {
180
+ const division = ts.isParenthesizedExpression(argument) ? argument.expression : argument;
181
+ if (
182
+ !ts.isBinaryExpression(division) ||
183
+ division.operatorToken.kind !== ts.SyntaxKind.SlashToken
184
+ ) {
185
+ throw new TlaTypeScriptError(
186
+ `Math.${method} only takes a division, as in Math.${method}(a / b)`,
187
+ node,
188
+ );
189
+ }
190
+ const left = translate(division.left);
191
+ const right = translate(division.right);
192
+ if (method === "floor") return `${left} \\div ${right}`;
193
+ context.prelude.add("Quot");
194
+ return `Quot(${left}, ${right})`;
195
+ }
196
+ if (method === "abs" && node.arguments.length === 1) {
197
+ return share(
198
+ translate(argument),
199
+ "value",
200
+ context,
201
+ (value) => `IF ${value} < 0 THEN -${value} ELSE ${value}`,
202
+ );
203
+ }
204
+ if ((method === "min" || method === "max") && node.arguments.length > 0) {
205
+ const comparison = method === "min" ? "<=" : ">=";
206
+ if (node.arguments.length === 1 && ts.isSpreadElement(argument)) {
207
+ const set = wrap(translateSet(argument.expression, scope, context));
208
+ const candidate = context.names.getFresh("candidate");
209
+ const other = context.names.getFresh("other");
210
+ return `CHOOSE ${candidate} \\in ${set} : \\A ${other} \\in ${set} : ${candidate} ${comparison} ${other}`;
211
+ }
212
+ return node.arguments
213
+ .map(translate)
214
+ .reduce((result, inner) =>
215
+ share(result, "best", context, (best) =>
216
+ share(
217
+ inner,
218
+ "value",
219
+ context,
220
+ (value) => `IF ${best} ${comparison} ${value} THEN ${best} ELSE ${value}`,
221
+ ),
222
+ ),
223
+ );
224
+ }
225
+ throw new TlaTypeScriptError(`Unsupported call: Math.${method}`, node);
226
+ };
227
+
228
+ const translateCall = (
229
+ node: ts.CallExpression,
230
+ scope: Scope,
231
+ context: Context,
232
+ isDefined: boolean,
233
+ ) => {
234
+ const symbol = getSymbol(node.expression, context.checker);
235
+ const helper = getTopLevelDeclaration(symbol);
236
+ if (helper !== undefined) return translateHelperCall(helper, node, scope, context);
237
+ if (!isMethodCall(node)) {
238
+ const operator = symbol === undefined ? undefined : scope.bindings.get(symbol);
239
+ if (operator === undefined) return translateLocalCall(node, scope, context);
240
+ const values = node.arguments.map((argument) => translateExpression(argument, scope, context));
241
+ return `${operator}(${values.join(", ")})`;
242
+ }
243
+ const receiver = node.expression.expression;
244
+ const method = node.expression.name.text;
245
+ const global = ts.isIdentifier(receiver) ? receiver.text : undefined;
246
+ if (global === "Math") return translateMath(node, method, scope, context);
247
+ const constructed =
248
+ global === "Object" && method === "fromEntries"
249
+ ? translateFunctionConstructor(node.arguments[0], scope, context)
250
+ : translateArrayConstructor(node, scope, context);
251
+ return constructed ?? translateMethod(node, scope, context, isDefined);
252
+ };
253
+
254
+ const translateToString = (node: ts.Expression, scope: Scope, context: Context) => {
255
+ const value = translateExpression(node, scope, context);
256
+ return getKind(node, context) === "string" ? value : `ToString(${value})`;
257
+ };
258
+
259
+ const translateTemplate = (node: ts.TemplateExpression, scope: Scope, context: Context) => {
260
+ const parts = [
261
+ ...(node.head.text === "" ? [] : [JSON.stringify(node.head.text)]),
262
+ ...node.templateSpans.flatMap((span) => {
263
+ const value = translateToString(span.expression, scope, context);
264
+ return span.literal.text === "" ? [value] : [value, JSON.stringify(span.literal.text)];
265
+ }),
266
+ ];
267
+ return parts.length === 1 ? parts[0] : parts.map(wrap).join(" \\o ");
268
+ };
269
+
270
+ const translateBinary = (node: ts.BinaryExpression, scope: Scope, context: Context) => {
271
+ const kind = node.operatorToken.kind;
272
+ const translate = (inner: ts.Expression) => wrap(translateExpression(inner, scope, context));
273
+ const isString =
274
+ getKind(node.left, context) === "string" || getKind(node.right, context) === "string";
275
+ const logical = LOGICAL_OPERATORS.get(kind);
276
+ if (logical !== undefined) {
277
+ if (!isBooleanLike(node.left, context) || !isBooleanLike(node.right, context)) {
278
+ throw new TlaTypeScriptError(
279
+ `${node.operatorToken.getText()} needs booleans, so compare explicitly`,
280
+ node,
281
+ );
282
+ }
283
+ return `${translate(node.left)} ${logical} ${translate(node.right)}`;
284
+ }
285
+ if (kind === ts.SyntaxKind.PlusToken && isString) {
286
+ const left = wrap(translateToString(node.left, scope, context));
287
+ return `${left} \\o ${wrap(translateToString(node.right, scope, context))}`;
288
+ }
289
+ if (kind === ts.SyntaxKind.PlusToken) return `${translate(node.left)} + ${translate(node.right)}`;
290
+ if (kind === ts.SyntaxKind.PercentToken) {
291
+ context.prelude.add("Rem");
292
+ return `Rem(${translateExpression(node.left, scope, context)}, ${translateExpression(node.right, scope, context)})`;
293
+ }
294
+ if (kind === ts.SyntaxKind.QuestionQuestionToken) {
295
+ context.prelude.add("Null");
296
+ context.prelude.add("Undefined");
297
+ return share(
298
+ translate(node.left),
299
+ "value",
300
+ context,
301
+ (value) => `IF ${value} \\in {Null, Undefined} THEN ${translate(node.right)} ELSE ${value}`,
302
+ );
303
+ }
304
+ if (kind === ts.SyntaxKind.InKeyword) {
305
+ return `${translate(node.left)} \\in DOMAIN ${translate(node.right)}`;
306
+ }
307
+ if (kind === ts.SyntaxKind.SlashToken) {
308
+ throw new TlaTypeScriptError("Write division as Math.floor(a / b) or Math.trunc(a / b)", node);
309
+ }
310
+ if (ORDERING_OPERATORS.has(kind) && isString) {
311
+ throw new TlaTypeScriptError("TLA+ strings have no order, so compare them with === only", node);
312
+ }
313
+ const operator = BINARY_OPERATORS.get(kind);
314
+ if (operator === undefined) {
315
+ throw new TlaTypeScriptError(
316
+ `Unsupported operator: ${node.operatorToken.getText()}`,
317
+ node.operatorToken,
318
+ );
319
+ }
320
+ return `${translate(node.left)} ${operator} ${translate(node.right)}`;
321
+ };
322
+
323
+ const getPreviousVariable = (name: string, node: ts.Node, context: Context) => {
324
+ const variable = [...context.variables].find((entry) => entry[0].name === name);
325
+ if (variable === undefined) throw new TlaTypeScriptError(`Unknown variable: ${name}`, node);
326
+ return variable[1];
327
+ };
328
+
329
+ const translateEnumMember = (node: ts.Node, symbol: ts.Symbol, context: Context) => {
330
+ const declaration = symbol.valueDeclaration;
331
+ const value =
332
+ declaration !== undefined && ts.isEnumMember(declaration)
333
+ ? context.checker.getConstantValue(declaration)
334
+ : undefined;
335
+ if (typeof value === "string") return translateString(value, context);
336
+ if (typeof value === "number" && Number.isInteger(value)) return String(value);
337
+ throw new TlaTypeScriptError("Unsupported enum member", node);
338
+ };
339
+
340
+ const translateDeclared = (
341
+ node: ts.Node,
342
+ symbol: ts.Symbol | undefined,
343
+ scope: Scope,
344
+ context: Context,
345
+ ) => {
346
+ if (symbol !== undefined && symbol.flags & ts.SymbolFlags.EnumMember) {
347
+ return translateEnumMember(node, symbol, context);
348
+ }
349
+ const declaration = getTopLevelDeclaration(symbol);
350
+ if (declaration === undefined) return undefined;
351
+ return getFunction(declaration) === undefined
352
+ ? translateHelperCall(declaration, undefined, scope, context)
353
+ : getDefinition(declaration, context).name;
354
+ };
355
+
356
+ const translateIdentifier = (node: ts.Identifier, scope: Scope, context: Context) => {
357
+ if (node.text === "undefined") {
358
+ context.prelude.add("Undefined");
359
+ return "Undefined";
360
+ }
361
+ const symbol = getSymbol(node, context.checker);
362
+ const binding = symbol === undefined ? undefined : scope.bindings.get(symbol);
363
+ if (binding !== undefined) return binding;
364
+ if (symbol !== undefined && symbol === scope.previous) {
365
+ return formatRecord(
366
+ context.checker
367
+ .getTypeAtLocation(node)
368
+ .getProperties()
369
+ .map((property) => ({
370
+ key: property.name,
371
+ value: getPreviousVariable(property.name, node, context),
372
+ })),
373
+ );
374
+ }
375
+ const declared = translateDeclared(node, symbol, scope, context);
376
+ if (declared !== undefined) return declared;
377
+ if (symbol !== undefined && context.variables.has(symbol)) {
378
+ throw new TlaTypeScriptError(`${node.text} can't be read here`, node);
379
+ }
380
+ throw new TlaTypeScriptError(`Unknown name: ${node.text}`, node);
381
+ };
382
+
383
+ const translatePropertyAccess = (
384
+ node: ts.PropertyAccessExpression,
385
+ scope: Scope,
386
+ context: Context,
387
+ ) => {
388
+ if (node.questionDotToken !== undefined) {
389
+ throw new TlaTypeScriptError("Optional chaining isn't supported", node);
390
+ }
391
+ const declared = translateDeclared(node, getSymbol(node, context.checker), scope, context);
392
+ if (declared !== undefined) return declared;
393
+ const receiver = node.expression;
394
+ const name = node.name.text;
395
+ if (
396
+ scope.previous !== undefined &&
397
+ ts.isIdentifier(receiver) &&
398
+ getSymbol(receiver, context.checker) === scope.previous
399
+ ) {
400
+ return getPreviousVariable(name, node, context);
401
+ }
402
+ const size =
403
+ name === "length" || name === "size" ? translateSize(receiver, scope, context) : undefined;
404
+ return size ?? `${wrap(translateExpression(receiver, scope, context))}.${name}`;
405
+ };
406
+
407
+ const translateElementAccess = (
408
+ node: ts.ElementAccessExpression,
409
+ scope: Scope,
410
+ context: Context,
411
+ ) => {
412
+ const value = wrap(translateExpression(node.expression, scope, context));
413
+ return `${value}[${translateKey(node, scope, context)}]`;
414
+ };
415
+
416
+ export const translateCondition = (node: ts.Expression, scope: Scope, context: Context) => {
417
+ if (!isBooleanLike(node, context)) {
418
+ throw new TlaTypeScriptError("Conditions must be booleans, so compare explicitly", node);
419
+ }
420
+ return translateExpression(node, scope, context);
421
+ };
422
+
423
+ export const translateNegatedCondition = (
424
+ node: ts.Expression,
425
+ scope: Scope,
426
+ context: Context,
427
+ ): string => {
428
+ if (ts.isParenthesizedExpression(node)) {
429
+ return translateNegatedCondition(node.expression, scope, context);
430
+ }
431
+ if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.ExclamationToken) {
432
+ return translateCondition(node.operand, scope, context);
433
+ }
434
+ if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
435
+ const left = translateNegatedCondition(node.left, scope, context);
436
+ const right = translateNegatedCondition(node.right, scope, context);
437
+ return `${wrap(left)} /\\ ${wrap(right)}`;
438
+ }
439
+ return `~${wrap(translateCondition(node, scope, context))}`;
440
+ };
441
+
442
+ export const translateExpression = (
443
+ node: ts.Expression,
444
+ scope: Scope,
445
+ context: Context,
446
+ isDefined = false,
447
+ ): string => {
448
+ if (
449
+ ts.isParenthesizedExpression(node) ||
450
+ ts.isAsExpression(node) ||
451
+ ts.isSatisfiesExpression(node) ||
452
+ ts.isTypeAssertionExpression(node)
453
+ ) {
454
+ return translateExpression(node.expression, scope, context, isDefined);
455
+ }
456
+ if (ts.isNonNullExpression(node)) {
457
+ return translateExpression(node.expression, scope, context, true);
458
+ }
459
+ if (ts.isNumericLiteral(node)) {
460
+ if (!Number.isInteger(Number(node.text))) {
461
+ throw new TlaTypeScriptError(`Only integers are supported: ${node.text}`, node);
462
+ }
463
+ return String(Number(node.text));
464
+ }
465
+ if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
466
+ return translateString(node.text, context);
467
+ }
468
+ if (ts.isTemplateExpression(node)) return translateTemplate(node, scope, context);
469
+ if (node.kind === ts.SyntaxKind.TrueKeyword) return "TRUE";
470
+ if (node.kind === ts.SyntaxKind.FalseKeyword) return "FALSE";
471
+ if (node.kind === ts.SyntaxKind.NullKeyword) {
472
+ context.prelude.add("Null");
473
+ return "Null";
474
+ }
475
+ if (ts.isIdentifier(node)) return translateIdentifier(node, scope, context);
476
+ if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.ExclamationToken) {
477
+ if (!isBooleanLike(node.operand, context)) {
478
+ throw new TlaTypeScriptError("! needs a boolean, so compare explicitly", node);
479
+ }
480
+ return `~${wrap(translateExpression(node.operand, scope, context))}`;
481
+ }
482
+ if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.MinusToken) {
483
+ return `-${wrap(translateExpression(node.operand, scope, context))}`;
484
+ }
485
+ if (ts.isBinaryExpression(node)) return translateBinary(node, scope, context);
486
+ if (ts.isConditionalExpression(node)) {
487
+ return `IF ${translateCondition(node.condition, scope, context)} THEN ${translateExpression(node.whenTrue, scope, context)} ELSE ${translateExpression(node.whenFalse, scope, context)}`;
488
+ }
489
+ if (ts.isArrayLiteralExpression(node)) return translateArrayLiteral(node, scope, context);
490
+ if (ts.isObjectLiteralExpression(node)) return translateObjectLiteral(node, scope, context);
491
+ if (ts.isPropertyAccessExpression(node)) return translatePropertyAccess(node, scope, context);
492
+ if (ts.isElementAccessExpression(node)) return translateElementAccess(node, scope, context);
493
+ if (ts.isCallExpression(node)) return translateCall(node, scope, context, isDefined);
494
+ if (ts.isNewExpression(node)) return translateNew(node, scope, context);
495
+ throw new TlaTypeScriptError(`Unsupported expression: ${node.getText()}`, node);
496
+ };
@@ -0,0 +1,154 @@
1
+ export type Formula = TextFormula | DisabledFormula | AndFormula | IfFormula | LetFormula;
2
+
3
+ interface TextFormula {
4
+ kind: "text";
5
+ text: string;
6
+ }
7
+
8
+ interface DisabledFormula {
9
+ kind: "disabled";
10
+ }
11
+
12
+ interface AndFormula {
13
+ kind: "and";
14
+ items: Formula[];
15
+ }
16
+
17
+ interface IfFormula {
18
+ kind: "if";
19
+ condition: string;
20
+ whenTrue: Formula;
21
+ whenFalse: Formula;
22
+ }
23
+
24
+ interface LetFormula {
25
+ kind: "let";
26
+ definitions: string[];
27
+ body: Formula;
28
+ }
29
+
30
+ export const DISABLED: Formula = { kind: "disabled" };
31
+
32
+ export const createText = (value: string): Formula => ({ kind: "text", text: value });
33
+
34
+ export const and = (items: Formula[]): Formula => {
35
+ const flattened = items.flatMap((item) => (item.kind === "and" ? item.items : [item]));
36
+ if (flattened.some((item) => item.kind === "disabled")) return DISABLED;
37
+ const kept = flattened.filter((item) => item.kind !== "text" || item.text !== "TRUE");
38
+ if (kept.length === 0) return createText("TRUE");
39
+ return kept.length === 1 ? kept[0] : { kind: "and", items: kept };
40
+ };
41
+
42
+ export const ifThenElse = (
43
+ condition: string,
44
+ whenTrue: Formula,
45
+ whenFalse: Formula,
46
+ negated = `~${wrap(condition)}`,
47
+ ): Formula => {
48
+ if (whenTrue.kind === "disabled" && whenFalse.kind === "disabled") return DISABLED;
49
+ if (whenFalse.kind === "disabled") return and([createText(condition), whenTrue]);
50
+ if (whenTrue.kind === "disabled") return and([createText(negated), whenFalse]);
51
+ return { kind: "if", condition, whenTrue, whenFalse };
52
+ };
53
+
54
+ export const letIn = (definitions: string[], body: Formula): Formula => {
55
+ if (body.kind === "disabled" || definitions.length === 0) return body;
56
+ if (body.kind === "let") return letIn([...definitions, ...body.definitions], body.body);
57
+ return { kind: "let", definitions, body };
58
+ };
59
+
60
+ const prefixLines = (lines: string[], first: string, rest: string) =>
61
+ lines.map((line, index) => `${index === 0 ? first : rest}${line}`);
62
+
63
+ const renderLines = (formula: Formula): string[] => {
64
+ if (formula.kind === "disabled") return ["FALSE"];
65
+ if (formula.kind === "text") return formula.text.split("\n");
66
+ if (formula.kind === "and") {
67
+ return formula.items.flatMap((item) => prefixLines(renderLines(item), "/\\ ", " "));
68
+ }
69
+ if (formula.kind === "if") {
70
+ return [
71
+ ...prefixLines(formula.condition.split("\n"), "IF ", " "),
72
+ ...prefixLines(renderLines(formula.whenTrue), "THEN ", " "),
73
+ ...prefixLines(renderLines(formula.whenFalse), "ELSE ", " "),
74
+ ];
75
+ }
76
+ return [
77
+ ...formula.definitions.flatMap((definition, index) =>
78
+ prefixLines(definition.split("\n"), index === 0 ? "LET " : " ", " "),
79
+ ),
80
+ ...prefixLines(renderLines(formula.body), "IN ", " "),
81
+ ];
82
+ };
83
+
84
+ export const render = (formula: Formula) => renderLines(formula).join("\n");
85
+
86
+ const OPENING = new Set(["(", "[", "{"]);
87
+ const CLOSING = new Set([")", "]", "}"]);
88
+
89
+ interface Scan {
90
+ depth: number;
91
+ isQuoted: boolean;
92
+ isEscaped: boolean;
93
+ isSkipped: boolean;
94
+ surface: string;
95
+ }
96
+
97
+ const getSurface = (expression: string) =>
98
+ [...expression].reduce<Scan>(
99
+ (scan, character, index) => {
100
+ if (scan.isSkipped) return { ...scan, isSkipped: false };
101
+ if (scan.isQuoted) {
102
+ return {
103
+ ...scan,
104
+ isQuoted: scan.isEscaped || character !== '"',
105
+ isEscaped: !scan.isEscaped && character === "\\",
106
+ };
107
+ }
108
+ const pair = expression.slice(index, index + 2);
109
+ if (pair === "<<") return { ...scan, depth: scan.depth + 1, isSkipped: true };
110
+ if (pair === ">>" && scan.depth > 0) {
111
+ return { ...scan, depth: scan.depth - 1, isSkipped: true };
112
+ }
113
+ if (character === '"') return { ...scan, isQuoted: true };
114
+ if (OPENING.has(character)) return { ...scan, depth: scan.depth + 1 };
115
+ if (CLOSING.has(character)) return { ...scan, depth: scan.depth - 1 };
116
+ return scan.depth === 0 ? { ...scan, surface: scan.surface + character } : scan;
117
+ },
118
+ { depth: 0, isQuoted: false, isEscaped: false, isSkipped: false, surface: "" },
119
+ ).surface;
120
+
121
+ const isAtomic = (expression: string) =>
122
+ expression !== "" &&
123
+ !/^[~-]/.test(expression) &&
124
+ !expression.includes("\n") &&
125
+ !getSurface(expression).includes(" ");
126
+
127
+ export const wrap = (expression: string) => (isAtomic(expression) ? expression : `(${expression})`);
128
+
129
+ const LOOSE_OPERATORS = [
130
+ " = ",
131
+ " # ",
132
+ " < ",
133
+ " > ",
134
+ " <= ",
135
+ " >= ",
136
+ " \\in ",
137
+ " \\notin ",
138
+ " \\subseteq ",
139
+ " /\\ ",
140
+ " \\/ ",
141
+ " => ",
142
+ " ~> ",
143
+ ];
144
+
145
+ export const wrapEquated = (expression: string) => {
146
+ if (expression.startsWith("~")) return `(${expression})`;
147
+ const surface = getSurface(expression);
148
+ return LOOSE_OPERATORS.some((operator) => surface.includes(operator))
149
+ ? `(${expression})`
150
+ : expression;
151
+ };
152
+
153
+ export const indent = (expression: string, prefix: string) =>
154
+ expression.split("\n").join(`\n${prefix}`);