tla-ts 0.0.3 → 0.0.4-dev.1a3acf6

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 (381) hide show
  1. package/README.md +46 -115
  2. package/dist/cli.cjs +1 -1
  3. package/dist/cli.js +1 -1
  4. package/dist/deciders.cjs +366 -0
  5. package/dist/deciders.js +366 -0
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +194 -8
  8. package/dist/index.d.ts +194 -8
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -4
  11. package/dist/parallel-worker.js +1 -4
  12. package/dist/prove-worker.cjs +9 -0
  13. package/dist/prove-worker.d.cts +9 -0
  14. package/dist/prove-worker.d.ts +9 -0
  15. package/dist/prove-worker.js +9 -0
  16. package/dist/prove.cjs +1006 -0
  17. package/dist/prove.js +1006 -0
  18. package/dist/run.cjs +45 -0
  19. package/dist/run.js +45 -0
  20. package/dist/tlapm.cjs +10 -0
  21. package/dist/tlapm.js +10 -0
  22. package/dist/transfer.cjs +1377 -18
  23. package/dist/transfer.js +1377 -18
  24. package/dist/worker.cjs +21 -0
  25. package/dist/worker.js +21 -0
  26. package/package.json +24 -11
  27. package/src/ast.ts +149 -8
  28. package/src/bags.ts +26 -30
  29. package/src/builtins.ts +45 -19
  30. package/src/bundled-modules.ts +3 -3
  31. package/src/check.ts +1182 -900
  32. package/src/cli/options.ts +109 -0
  33. package/src/cli/run.ts +63 -0
  34. package/src/cli/shared.ts +106 -0
  35. package/src/cli/tlapm.ts +374 -0
  36. package/src/cli/tlc.ts +941 -0
  37. package/src/cli/xml-exporter.ts +221 -0
  38. package/src/cli.ts +9 -2
  39. package/src/codegen.ts +112 -51
  40. package/src/config.ts +254 -181
  41. package/src/dependencies.ts +5 -7
  42. package/src/environment.ts +579 -184
  43. package/src/errors.ts +287 -4
  44. package/src/evaluate.ts +1095 -365
  45. package/src/exit-codes.ts +22 -43
  46. package/src/fingerprints.ts +49 -14
  47. package/src/index.ts +11 -0
  48. package/src/instances.ts +73 -60
  49. package/src/java-overrides.ts +183 -66
  50. package/src/json.ts +31 -36
  51. package/src/levels.ts +197 -54
  52. package/src/lexer.ts +127 -30
  53. package/src/liveness-checker.ts +894 -0
  54. package/src/liveness.ts +246 -596
  55. package/src/{obligation-action.ts → obligations/action.ts} +248 -74
  56. package/src/{obligation-anon.ts → obligations/anonymize.ts} +55 -57
  57. package/src/obligations/equality.ts +260 -0
  58. package/src/obligations/expression.ts +618 -0
  59. package/src/{obligation-format.ts → obligations/format.ts} +7 -8
  60. package/src/obligations/generate.ts +457 -0
  61. package/src/{obligations.ts → obligations/index.ts} +46 -32
  62. package/src/{obligation-levels.ts → obligations/levels.ts} +44 -40
  63. package/src/obligations/module.ts +445 -0
  64. package/src/obligations/normalize.ts +554 -0
  65. package/src/obligations/operators.ts +176 -0
  66. package/src/obligations/pragma.ts +195 -0
  67. package/src/{obligation-printer.ts → obligations/printer.ts} +65 -230
  68. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
  69. package/src/obligations/regroup.ts +100 -0
  70. package/src/{obligation-generate.ts → obligations/simplify.ts} +130 -536
  71. package/src/{obligation-source.ts → obligations/source.ts} +174 -216
  72. package/src/{obligation-deref.ts → obligations/subexpression.ts} +84 -115
  73. package/src/obligations/substitution.ts +261 -0
  74. package/src/obligations/temporal.ts +321 -0
  75. package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
  76. package/src/parallel-worker.ts +184 -235
  77. package/src/parallel.ts +156 -91
  78. package/src/parser.ts +490 -188
  79. package/src/pcal/ast.ts +755 -0
  80. package/src/pcal/parse.ts +1487 -0
  81. package/src/pcal/tokenize.ts +487 -0
  82. package/src/pcal/translate.ts +1151 -0
  83. package/src/pcal/validate.ts +444 -0
  84. package/src/prover/decide-pool.ts +95 -0
  85. package/src/prover/deciders.ts +33 -0
  86. package/src/prover/first-order.ts +175 -0
  87. package/src/prover/isabelle/LICENSE +36 -0
  88. package/src/prover/isabelle/LICENSE-tlapm +26 -0
  89. package/src/prover/isabelle/decide.ts +44 -0
  90. package/src/prover/isabelle/encode.ts +445 -0
  91. package/src/prover/isabelle/isar/inner-syntax.ts +579 -0
  92. package/src/prover/isabelle/isar/method.ts +367 -0
  93. package/src/prover/isabelle/isar/proof.ts +28 -0
  94. package/src/prover/isabelle/isar/statement.ts +57 -0
  95. package/src/prover/isabelle/isar/theory.ts +192 -0
  96. package/src/prover/isabelle/isar/type-check.ts +278 -0
  97. package/src/prover/isabelle/provers/blast/blast.ts +258 -0
  98. package/src/prover/isabelle/provers/blast/branch.ts +322 -0
  99. package/src/prover/isabelle/provers/blast/prove.ts +347 -0
  100. package/src/prover/isabelle/provers/blast/rules.ts +330 -0
  101. package/src/prover/isabelle/provers/blast/state.ts +180 -0
  102. package/src/prover/isabelle/provers/blast/term.ts +546 -0
  103. package/src/prover/isabelle/provers/clasimp.ts +150 -0
  104. package/src/prover/isabelle/provers/classical.ts +389 -0
  105. package/src/prover/isabelle/provers/hypsubst.ts +433 -0
  106. package/src/prover/isabelle/pure/bicompose.ts +174 -0
  107. package/src/prover/isabelle/pure/consts.ts +32 -0
  108. package/src/prover/isabelle/pure/conv.ts +79 -0
  109. package/src/prover/isabelle/pure/drule.ts +264 -0
  110. package/src/prover/isabelle/pure/envir.ts +331 -0
  111. package/src/prover/isabelle/pure/goal.ts +53 -0
  112. package/src/prover/isabelle/pure/interrupt.ts +16 -0
  113. package/src/prover/isabelle/pure/list.ts +12 -0
  114. package/src/prover/isabelle/pure/logic.ts +330 -0
  115. package/src/prover/isabelle/pure/name.ts +98 -0
  116. package/src/prover/isabelle/pure/net.ts +215 -0
  117. package/src/prover/isabelle/pure/object-logic.ts +41 -0
  118. package/src/prover/isabelle/pure/pattern.ts +631 -0
  119. package/src/prover/isabelle/pure/raw-simplifier.ts +338 -0
  120. package/src/prover/isabelle/pure/rewriter.ts +602 -0
  121. package/src/prover/isabelle/pure/search.ts +68 -0
  122. package/src/prover/isabelle/pure/seq.ts +133 -0
  123. package/src/prover/isabelle/pure/simplifier.ts +106 -0
  124. package/src/prover/isabelle/pure/table.ts +201 -0
  125. package/src/prover/isabelle/pure/tactic.ts +168 -0
  126. package/src/prover/isabelle/pure/tactical.ts +264 -0
  127. package/src/prover/isabelle/pure/term-ord.ts +105 -0
  128. package/src/prover/isabelle/pure/term.ts +688 -0
  129. package/src/prover/isabelle/pure/thm.ts +783 -0
  130. package/src/prover/isabelle/pure/type.ts +121 -0
  131. package/src/prover/isabelle/pure/unify.ts +753 -0
  132. package/src/prover/isabelle/pure/variable.ts +25 -0
  133. package/src/prover/isabelle/tla/classical-setup.ts +101 -0
  134. package/src/prover/isabelle/tla/context.ts +74 -0
  135. package/src/prover/isabelle/tla/logic-data.ts +5 -0
  136. package/src/prover/isabelle/tla/logic.ts +215 -0
  137. package/src/prover/isabelle/tla/simpdata.ts +241 -0
  138. package/src/prover/isabelle/tools/intuitionistic.ts +132 -0
  139. package/src/prover/ocaml.ts +22 -0
  140. package/src/prover/prep/action.ts +508 -0
  141. package/src/prover/prep/enabled-axioms.ts +189 -0
  142. package/src/prover/prep/fingerprint.ts +388 -0
  143. package/src/prover/prep/level-comparison.ts +529 -0
  144. package/src/prover/prep/md5.ts +60 -0
  145. package/src/prover/prep/methods.ts +221 -0
  146. package/src/prover/prep/normalize.ts +309 -0
  147. package/src/prover/prove-worker.ts +22 -0
  148. package/src/prover/prove.ts +492 -0
  149. package/src/prover/ptl/decide.ts +68 -0
  150. package/src/prover/ptl/encode.ts +244 -0
  151. package/src/prover/ptl/sat.ts +151 -0
  152. package/src/prover/ptl/tableau.ts +276 -0
  153. package/src/prover/smt/axioms.ts +209 -0
  154. package/src/prover/smt/context.ts +108 -0
  155. package/src/prover/smt/data.ts +636 -0
  156. package/src/prover/smt/encode.ts +275 -0
  157. package/src/prover/smt/extensionality.ts +65 -0
  158. package/src/prover/smt/flatten.ts +112 -0
  159. package/src/prover/smt/format.ts +154 -0
  160. package/src/prover/smt/instances.ts +181 -0
  161. package/src/prover/smt/rewrite.ts +766 -0
  162. package/src/prover/smt/solver/act-cache.ts +265 -0
  163. package/src/prover/smt/solver/arith-rewriter.ts +962 -0
  164. package/src/prover/smt/solver/array.ts +22 -0
  165. package/src/prover/smt/solver/asserted-formulas.ts +469 -0
  166. package/src/prover/smt/solver/ast-lt.ts +157 -0
  167. package/src/prover/smt/solver/ast-util.ts +91 -0
  168. package/src/prover/smt/solver/ast.ts +1315 -0
  169. package/src/prover/smt/solver/auf-solver.ts +572 -0
  170. package/src/prover/smt/solver/case-split-queue.ts +178 -0
  171. package/src/prover/smt/solver/cg-table.ts +175 -0
  172. package/src/prover/smt/solver/clause.ts +276 -0
  173. package/src/prover/smt/solver/conflict-resolution.ts +343 -0
  174. package/src/prover/smt/solver/context.ts +1292 -0
  175. package/src/prover/smt/solver/ctx-simplify.ts +334 -0
  176. package/src/prover/smt/solver/der.ts +224 -0
  177. package/src/prover/smt/solver/dyn-ack.ts +141 -0
  178. package/src/prover/smt/solver/e-matching.ts +659 -0
  179. package/src/prover/smt/solver/enode.ts +259 -0
  180. package/src/prover/smt/solver/expr-ref.ts +21 -0
  181. package/src/prover/smt/solver/expr-safe-replace.ts +172 -0
  182. package/src/prover/smt/solver/fingerprints.ts +92 -0
  183. package/src/prover/smt/solver/flat-literals.ts +51 -0
  184. package/src/prover/smt/solver/goal.ts +138 -0
  185. package/src/prover/smt/solver/hash.ts +173 -0
  186. package/src/prover/smt/solver/hashtable.ts +166 -0
  187. package/src/prover/smt/solver/internalizer.ts +1381 -0
  188. package/src/prover/smt/solver/lbool.ts +5 -0
  189. package/src/prover/smt/solver/literal.ts +24 -0
  190. package/src/prover/smt/solver/lp/bound-propagator.ts +391 -0
  191. package/src/prover/smt/solver/lp/constraints.ts +78 -0
  192. package/src/prover/smt/solver/lp/containers.ts +296 -0
  193. package/src/prover/smt/solver/lp/core-solver.ts +504 -0
  194. package/src/prover/smt/solver/lp/cross-nested.ts +224 -0
  195. package/src/prover/smt/solver/lp/dep-intervals.ts +642 -0
  196. package/src/prover/smt/solver/lp/dependency.ts +51 -0
  197. package/src/prover/smt/solver/lp/dioph-eq.ts +1181 -0
  198. package/src/prover/smt/solver/lp/explanation.ts +46 -0
  199. package/src/prover/smt/solver/lp/gomory.ts +255 -0
  200. package/src/prover/smt/solver/lp/hnf-cutter.ts +125 -0
  201. package/src/prover/smt/solver/lp/hnf.ts +281 -0
  202. package/src/prover/smt/solver/lp/int-cube.ts +295 -0
  203. package/src/prover/smt/solver/lp/int-solver.ts +514 -0
  204. package/src/prover/smt/solver/lp/lar-solver.ts +816 -0
  205. package/src/prover/smt/solver/lp/lar-term.ts +62 -0
  206. package/src/prover/smt/solver/lp/lp-settings.ts +91 -0
  207. package/src/prover/smt/solver/lp/maximize-term.ts +347 -0
  208. package/src/prover/smt/solver/lp/nex-creator.ts +381 -0
  209. package/src/prover/smt/solver/lp/nex.ts +120 -0
  210. package/src/prover/smt/solver/lp/nla-backoff.ts +43 -0
  211. package/src/prover/smt/solver/lp/nla-basics.ts +398 -0
  212. package/src/prover/smt/solver/lp/nla-core.ts +968 -0
  213. package/src/prover/smt/solver/lp/nla-divisions.ts +332 -0
  214. package/src/prover/smt/solver/lp/nla-emonics.ts +373 -0
  215. package/src/prover/smt/solver/lp/nla-factorization.ts +30 -0
  216. package/src/prover/smt/solver/lp/nla-grobner.ts +904 -0
  217. package/src/prover/smt/solver/lp/nla-horner.ts +126 -0
  218. package/src/prover/smt/solver/lp/nla-intervals.ts +265 -0
  219. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  220. package/src/prover/smt/solver/lp/nla-monotone.ts +59 -0
  221. package/src/prover/smt/solver/lp/nla-order.ts +307 -0
  222. package/src/prover/smt/solver/lp/nla-patcher.ts +112 -0
  223. package/src/prover/smt/solver/lp/nla-tangents.ts +251 -0
  224. package/src/prover/smt/solver/lp/nla-throttle.ts +85 -0
  225. package/src/prover/smt/solver/lp/nla-types.ts +124 -0
  226. package/src/prover/smt/solver/lp/nla-var-eqs.ts +141 -0
  227. package/src/prover/smt/solver/lp/nra-solver.ts +440 -0
  228. package/src/prover/smt/solver/lp/numeric-pair.ts +65 -0
  229. package/src/prover/smt/solver/lp/pdd-interval.ts +31 -0
  230. package/src/prover/smt/solver/lp/pdd-simplifier.ts +184 -0
  231. package/src/prover/smt/solver/lp/pdd-solver.ts +408 -0
  232. package/src/prover/smt/solver/lp/pdd.ts +971 -0
  233. package/src/prover/smt/solver/lp/random-updater.ts +138 -0
  234. package/src/prover/smt/solver/lp/static-matrix.ts +246 -0
  235. package/src/prover/smt/solver/lp/union-find.ts +96 -0
  236. package/src/prover/smt/solver/mam-compiler.ts +847 -0
  237. package/src/prover/smt/solver/mam-interpreter.ts +400 -0
  238. package/src/prover/smt/solver/maximize-ac-sharing.ts +118 -0
  239. package/src/prover/smt/solver/model-checker.ts +347 -0
  240. package/src/prover/smt/solver/model-evaluator.ts +262 -0
  241. package/src/prover/smt/solver/model-finder.ts +155 -0
  242. package/src/prover/smt/solver/model-generator.ts +97 -0
  243. package/src/prover/smt/solver/model-macro-solver.ts +728 -0
  244. package/src/prover/smt/solver/nlsat/algebraic.ts +1161 -0
  245. package/src/prover/smt/solver/nlsat/atoms.ts +238 -0
  246. package/src/prover/smt/solver/nlsat/evaluator.ts +303 -0
  247. package/src/prover/smt/solver/nlsat/explain.ts +607 -0
  248. package/src/prover/smt/solver/nlsat/interval-set.ts +351 -0
  249. package/src/prover/smt/solver/nlsat/levelwise.ts +737 -0
  250. package/src/prover/smt/solver/nlsat/mpbq.ts +161 -0
  251. package/src/prover/smt/solver/nlsat/polynomial.ts +1722 -0
  252. package/src/prover/smt/solver/nlsat/solver.ts +911 -0
  253. package/src/prover/smt/solver/nlsat/types.ts +43 -0
  254. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  255. package/src/prover/smt/solver/nlsat/upolynomial.ts +996 -0
  256. package/src/prover/smt/solver/nnf.ts +469 -0
  257. package/src/prover/smt/solver/pattern-inference.ts +351 -0
  258. package/src/prover/smt/solver/poly-rewriter.ts +477 -0
  259. package/src/prover/smt/solver/propagate-values.ts +83 -0
  260. package/src/prover/smt/solver/proto-model.ts +551 -0
  261. package/src/prover/smt/solver/pull-quant.ts +139 -0
  262. package/src/prover/smt/solver/qe-lite-der.ts +526 -0
  263. package/src/prover/smt/solver/qe-lite-fm.ts +576 -0
  264. package/src/prover/smt/solver/qe-lite.ts +381 -0
  265. package/src/prover/smt/solver/qi-queue.ts +362 -0
  266. package/src/prover/smt/solver/quant-tactics.ts +117 -0
  267. package/src/prover/smt/solver/quantifier-analyzer.ts +562 -0
  268. package/src/prover/smt/solver/quantifier-manager.ts +186 -0
  269. package/src/prover/smt/solver/random-gen.ts +10 -0
  270. package/src/prover/smt/solver/rational.ts +165 -0
  271. package/src/prover/smt/solver/ref-vector.ts +62 -0
  272. package/src/prover/smt/solver/relevancy.ts +247 -0
  273. package/src/prover/smt/solver/rewriter-tpl.ts +1159 -0
  274. package/src/prover/smt/solver/rewriter.ts +843 -0
  275. package/src/prover/smt/solver/rlimit.ts +79 -0
  276. package/src/prover/smt/solver/smtlib-parser.ts +526 -0
  277. package/src/prover/smt/solver/solver.ts +71 -0
  278. package/src/prover/smt/solver/sort.ts +35 -0
  279. package/src/prover/smt/solver/sticky-generations.ts +69 -0
  280. package/src/prover/smt/solver/theory-lra-axioms.ts +340 -0
  281. package/src/prover/smt/solver/theory-lra-bounds.ts +226 -0
  282. package/src/prover/smt/solver/theory-lra-final-check.ts +252 -0
  283. package/src/prover/smt/solver/theory-lra-internalize.ts +476 -0
  284. package/src/prover/smt/solver/theory-lra-model.ts +243 -0
  285. package/src/prover/smt/solver/theory-lra-propagate.ts +405 -0
  286. package/src/prover/smt/solver/theory-lra-state.ts +43 -0
  287. package/src/prover/smt/solver/theory-lra.ts +56 -0
  288. package/src/prover/smt/solver/var-subst.ts +258 -0
  289. package/src/prover/smt/solver/z3-license.txt +10 -0
  290. package/src/prover/smt/table.ts +170 -0
  291. package/src/prover/tlapm/cache.ts +236 -0
  292. package/src/prover/tlapm/ocaml-marshal.ts +166 -0
  293. package/src/prover/tlapm/tlapm.ts +96 -0
  294. package/src/prover/tlaps-module.ts +510 -0
  295. package/src/prover/verdict.ts +13 -0
  296. package/src/prover/zenon/LICENSE +32 -0
  297. package/src/prover/zenon/check/check.ts +105 -0
  298. package/src/prover/zenon/check/definitions.ts +144 -0
  299. package/src/prover/zenon/check/equality.ts +182 -0
  300. package/src/prover/zenon/check/functions.ts +62 -0
  301. package/src/prover/zenon/check/keys.ts +125 -0
  302. package/src/prover/zenon/check/propositional.ts +104 -0
  303. package/src/prover/zenon/check/records.ts +188 -0
  304. package/src/prover/zenon/check/relations.ts +121 -0
  305. package/src/prover/zenon/check/rewrites.ts +224 -0
  306. package/src/prover/zenon/check/sets.ts +302 -0
  307. package/src/prover/zenon/check/terms.ts +127 -0
  308. package/src/prover/zenon/check/tla.ts +126 -0
  309. package/src/prover/zenon/decide.ts +107 -0
  310. package/src/prover/zenon/encode.ts +378 -0
  311. package/src/prover/zenon/eqrel.ts +300 -0
  312. package/src/prover/zenon/equality-rules.ts +435 -0
  313. package/src/prover/zenon/expr.ts +551 -0
  314. package/src/prover/zenon/index-table.ts +350 -0
  315. package/src/prover/zenon/isar-case.ts +513 -0
  316. package/src/prover/zenon/isar.ts +1249 -0
  317. package/src/prover/zenon/limits.ts +15 -0
  318. package/src/prover/zenon/llproof.ts +173 -0
  319. package/src/prover/zenon/mltoll.ts +1566 -0
  320. package/src/prover/zenon/node.ts +297 -0
  321. package/src/prover/zenon/ocaml.ts +169 -0
  322. package/src/prover/zenon/parse.ts +247 -0
  323. package/src/prover/zenon/phrase.ts +191 -0
  324. package/src/prover/zenon/proof.ts +198 -0
  325. package/src/prover/zenon/propositional-rules.ts +387 -0
  326. package/src/prover/zenon/rules.ts +94 -0
  327. package/src/prover/zenon/search.ts +288 -0
  328. package/src/prover/zenon/tla/functions.ts +151 -0
  329. package/src/prover/zenon/tla/llproof.ts +480 -0
  330. package/src/prover/zenon/tla/records.ts +225 -0
  331. package/src/prover/zenon/tla/rewrites.ts +447 -0
  332. package/src/prover/zenon/tla/sets.ts +304 -0
  333. package/src/prover/zenon/tla/terms.ts +162 -0
  334. package/src/prover/zenon/tla/tla.ts +506 -0
  335. package/src/randomization.ts +39 -27
  336. package/src/resolve.ts +1474 -426
  337. package/src/runtime.ts +25 -7
  338. package/src/sany/builtins.ts +147 -0
  339. package/src/sany/generator.ts +3111 -0
  340. package/src/sany/levels.ts +1205 -0
  341. package/src/sany/lexer.ts +544 -0
  342. package/src/sany/linter.ts +122 -0
  343. package/src/sany/modules.ts +1398 -0
  344. package/src/sany/nodes.ts +463 -0
  345. package/src/sany/parse-error.ts +2161 -0
  346. package/src/sany/report.ts +355 -0
  347. package/src/sany/selectors.ts +736 -0
  348. package/src/sany/source.ts +247 -0
  349. package/src/sany/xml.ts +1016 -0
  350. package/src/search.ts +969 -0
  351. package/src/spec-description.ts +66 -29
  352. package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
  353. package/src/standard-modules.ts +215 -164
  354. package/src/state-graph.ts +181 -0
  355. package/src/subexpressions.ts +231 -171
  356. package/src/substitution-levels.ts +40 -19
  357. package/src/successors.ts +253 -125
  358. package/src/symmetry.ts +194 -54
  359. package/src/tableau.ts +60 -32
  360. package/src/tlc/fingerprint.ts +214 -0
  361. package/src/{tlc-modules.ts → tlc/jar-data.ts} +4 -0
  362. package/src/tlc/messages.ts +441 -0
  363. package/src/{tlc-order.ts → tlc/order.ts} +84 -16
  364. package/src/{tlc-random.ts → tlc/random.ts} +30 -189
  365. package/src/tlc/replay.ts +659 -0
  366. package/src/{tlc-summary.ts → tlc/summary.ts} +20 -5
  367. package/src/{tlc-module.ts → tlc/tlc-operators.ts} +59 -50
  368. package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +63 -45
  369. package/src/tlc/version.ts +19 -0
  370. package/src/transfer.ts +44 -32
  371. package/src/values.ts +843 -241
  372. package/src/worker.ts +62 -0
  373. package/dist/parallel.cjs +0 -12
  374. package/dist/parallel.js +0 -12
  375. package/dist/run-cli.cjs +0 -28
  376. package/dist/run-cli.js +0 -28
  377. package/src/canonical.ts +0 -39
  378. package/src/cli-options.ts +0 -58
  379. package/src/obligation-expression.ts +0 -1060
  380. package/src/obligation-module.ts +0 -1042
  381. package/src/run-cli.ts +0 -478
@@ -0,0 +1,755 @@
1
+ import { PcalBugError, PcalError, PcalRuntimeError } from "../errors";
2
+ import type { TlcVersion } from "../tlc/version";
3
+
4
+ // TLAToken's types.
5
+ export const PCAL_TOKEN = { builtin: 1, number: 2, string: 3, ident: 4, added: 5 } as const;
6
+
7
+ export interface PcalToken {
8
+ string: string;
9
+ column: number;
10
+ type: number;
11
+ }
12
+
13
+ // TLAExpr: the tokens of an expression, line by line, and for each line the token of an earlier
14
+ // line it is aligned under, with that token's column when the expression was normalized.
15
+ export interface PcalExpr {
16
+ tokens: PcalToken[][];
17
+ anchorTokens: (PcalToken | undefined)[] | undefined;
18
+ anchorTokCol: number[] | undefined;
19
+ }
20
+
21
+ // IntPair, as the "Java coordinates" of a token in an expression.
22
+ interface PcalCoord {
23
+ line: number;
24
+ item: number;
25
+ }
26
+
27
+ // PcalParams: the translator's options, which the Java keeps in static fields that SANY never
28
+ // resets, so options one module sets carry over to the modules SANY validates after it.
29
+ export interface PcalParams {
30
+ labelFlag: boolean;
31
+ labelRoot: string;
32
+ fairnessOption: string;
33
+ checkTermination: boolean;
34
+ specOption: boolean;
35
+ myspecOption: boolean;
36
+ inputVersionNumber: number;
37
+ }
38
+
39
+ // PcalParams.versionWeight.
40
+ export const PCAL_VERSION_WEIGHT = 1903;
41
+
42
+ export const createPcalParams = (): PcalParams => ({
43
+ labelFlag: false,
44
+ labelRoot: "Lbl_",
45
+ fairnessOption: "",
46
+ checkTermination: false,
47
+ specOption: false,
48
+ myspecOption: false,
49
+ inputVersionNumber: PCAL_VERSION_WEIGHT,
50
+ });
51
+
52
+ // PcalParams.VersionToNumber: "1.5" is 1500, and -1 means a malformed version.
53
+ export const getPcalVersionNumber = (text: string) => {
54
+ const state = { result: 0, digitsAfterDecimal: 0, isAfterDecimal: false };
55
+ for (const char of text) {
56
+ if (char === ".") {
57
+ state.isAfterDecimal = true;
58
+ continue;
59
+ }
60
+ if (char < "0" || char > "9") return -1;
61
+ state.result = 10 * state.result + Number(char);
62
+ if (state.isAfterDecimal) state.digitsAfterDecimal += 1;
63
+ if (state.digitsAfterDecimal > 3) return -1;
64
+ }
65
+ return state.result * 10 ** Math.max(0, 3 - state.digitsAfterDecimal);
66
+ };
67
+
68
+ interface PcalBase {
69
+ col: number;
70
+ line: number;
71
+ macroCol: number;
72
+ macroLine: number;
73
+ lbl: string;
74
+ }
75
+
76
+ interface PcalUniprocess extends PcalBase {
77
+ kind: "Uniprocess";
78
+ name: string;
79
+ decls: PcalVarDecl[];
80
+ defs: PcalExpr;
81
+ macros: PcalMacro[];
82
+ prcds: PcalProcedure[];
83
+ body: PcalStmt[];
84
+ }
85
+
86
+ interface PcalMultiprocess extends PcalBase {
87
+ kind: "Multiprocess";
88
+ name: string;
89
+ decls: PcalVarDecl[];
90
+ defs: PcalExpr;
91
+ macros: PcalMacro[];
92
+ prcds: PcalProcedure[];
93
+ procs: PcalProcess[];
94
+ }
95
+
96
+ export interface PcalProcedure extends PcalBase {
97
+ kind: "Procedure";
98
+ name: string;
99
+ minusLabels: string[];
100
+ plusLabels: string[];
101
+ proceduresCalled: string[];
102
+ params: PcalPVarDecl[];
103
+ decls: PcalPVarDecl[];
104
+ body: PcalStmt[];
105
+ }
106
+
107
+ // AST.UNFAIR_PROC, WF_PROC and SF_PROC index FairnessString.
108
+ const PCAL_FAIRNESS = ["unfair", "wf", "sf"];
109
+
110
+ export interface PcalProcess extends PcalBase {
111
+ kind: "Process";
112
+ name: string;
113
+ fairness: number;
114
+ minusLabels: string[];
115
+ plusLabels: string[];
116
+ proceduresCalled: string[];
117
+ isEq: boolean;
118
+ id: PcalExpr;
119
+ decls: PcalVarDecl[];
120
+ body: PcalStmt[];
121
+ }
122
+
123
+ export interface PcalVarDecl extends PcalBase {
124
+ kind: "VarDecl";
125
+ var: string;
126
+ isEq: boolean;
127
+ val: PcalExpr;
128
+ }
129
+
130
+ export interface PcalPVarDecl extends PcalBase {
131
+ kind: "PVarDecl";
132
+ var: string;
133
+ val: PcalExpr;
134
+ }
135
+
136
+ export interface PcalLabeledStmt extends PcalBase {
137
+ kind: "LabeledStmt";
138
+ label: string;
139
+ stmts: PcalStmt[];
140
+ }
141
+
142
+ export interface PcalWhile extends PcalBase {
143
+ kind: "While";
144
+ test: PcalExpr;
145
+ unlabDo: PcalStmt[];
146
+ labDo: PcalLabeledStmt[];
147
+ }
148
+
149
+ export interface PcalAssign extends PcalBase {
150
+ kind: "Assign";
151
+ ass: PcalSingleAssign[];
152
+ }
153
+
154
+ export interface PcalSingleAssign extends PcalBase {
155
+ kind: "SingleAssign";
156
+ lhs: PcalLhs;
157
+ rhs: PcalExpr;
158
+ }
159
+
160
+ export interface PcalLhs extends PcalBase {
161
+ kind: "Lhs";
162
+ var: string;
163
+ sub: PcalExpr;
164
+ }
165
+
166
+ interface PcalIf extends PcalBase {
167
+ kind: "If";
168
+ test: PcalExpr;
169
+ Then: PcalStmt[];
170
+ Else: PcalStmt[];
171
+ }
172
+
173
+ interface PcalEither extends PcalBase {
174
+ kind: "Either";
175
+ ors: PcalStmt[][];
176
+ }
177
+
178
+ export interface PcalWith extends PcalBase {
179
+ kind: "With";
180
+ var: string;
181
+ isEq: boolean;
182
+ exp: PcalExpr;
183
+ Do: PcalStmt[];
184
+ }
185
+
186
+ export interface PcalWhen extends PcalBase {
187
+ kind: "When";
188
+ exp: PcalExpr;
189
+ }
190
+
191
+ interface PcalPrintS extends PcalBase {
192
+ kind: "PrintS";
193
+ exp: PcalExpr;
194
+ }
195
+
196
+ interface PcalAssert extends PcalBase {
197
+ kind: "Assert";
198
+ exp: PcalExpr;
199
+ }
200
+
201
+ interface PcalSkip extends PcalBase {
202
+ kind: "Skip";
203
+ }
204
+
205
+ export interface PcalLabelIf extends PcalBase {
206
+ kind: "LabelIf";
207
+ test: PcalExpr;
208
+ unlabThen: PcalStmt[];
209
+ labThen: PcalLabeledStmt[];
210
+ unlabElse: PcalStmt[];
211
+ labElse: PcalLabeledStmt[];
212
+ }
213
+
214
+ export interface PcalLabelEither extends PcalBase {
215
+ kind: "LabelEither";
216
+ clauses: PcalClause[];
217
+ }
218
+
219
+ export interface PcalClause extends PcalBase {
220
+ kind: "Clause";
221
+ unlabOr: PcalStmt[];
222
+ labOr: PcalLabeledStmt[];
223
+ }
224
+
225
+ export interface PcalCall extends PcalBase {
226
+ kind: "Call";
227
+ returnTo: string;
228
+ to: string;
229
+ args: PcalExpr[];
230
+ }
231
+
232
+ // A Return or CallReturn outside a procedure has a null from, which Java prints as "null".
233
+ export interface PcalReturn extends PcalBase {
234
+ kind: "Return";
235
+ from: string | undefined;
236
+ }
237
+
238
+ export interface PcalCallReturn extends PcalBase {
239
+ kind: "CallReturn";
240
+ from: string | undefined;
241
+ to: string;
242
+ args: PcalExpr[];
243
+ }
244
+
245
+ interface PcalCallGoto extends PcalBase {
246
+ kind: "CallGoto";
247
+ after: string;
248
+ to: string;
249
+ args: PcalExpr[];
250
+ }
251
+
252
+ interface PcalGoto extends PcalBase {
253
+ kind: "Goto";
254
+ to: string;
255
+ }
256
+
257
+ export interface PcalMacro extends PcalBase {
258
+ kind: "Macro";
259
+ name: string;
260
+ params: string[];
261
+ body: PcalStmt[];
262
+ }
263
+
264
+ export interface PcalMacroCall extends PcalBase {
265
+ kind: "MacroCall";
266
+ name: string;
267
+ args: PcalExpr[];
268
+ }
269
+
270
+ export type PcalStmt =
271
+ | PcalLabeledStmt
272
+ | PcalWhile
273
+ | PcalAssign
274
+ | PcalIf
275
+ | PcalEither
276
+ | PcalWith
277
+ | PcalWhen
278
+ | PcalPrintS
279
+ | PcalAssert
280
+ | PcalSkip
281
+ | PcalLabelIf
282
+ | PcalLabelEither
283
+ | PcalCall
284
+ | PcalReturn
285
+ | PcalCallReturn
286
+ | PcalCallGoto
287
+ | PcalGoto
288
+ | PcalMacroCall;
289
+
290
+ export type PcalAlgorithm = PcalUniprocess | PcalMultiprocess;
291
+
292
+ export type PcalNode =
293
+ | PcalStmt
294
+ | PcalAlgorithm
295
+ | PcalProcedure
296
+ | PcalProcess
297
+ | PcalVarDecl
298
+ | PcalPVarDecl
299
+ | PcalSingleAssign
300
+ | PcalLhs
301
+ | PcalClause
302
+ | PcalMacro;
303
+
304
+ export const createPcalBase = (): PcalBase => ({
305
+ col: 0,
306
+ line: 0,
307
+ macroCol: 0,
308
+ macroLine: -1,
309
+ lbl: "",
310
+ });
311
+
312
+ // AST.location.
313
+ export const getPcalLocation = (node: PcalBase) =>
314
+ node.macroLine < 0
315
+ ? `line ${node.line}, column ${node.col}`
316
+ : `line ${node.line}, column ${node.col} of macro called at line ${node.macroLine}, column ${node.macroCol}`;
317
+
318
+ // A Java cast of a statement to AST.LabeledStmt.
319
+ export const toLabeledStmt = (node: PcalStmt) => {
320
+ if (node.kind !== "LabeledStmt") throw new PcalRuntimeError(`ClassCastException: ${node.kind}`);
321
+ return node;
322
+ };
323
+
324
+ // Vector.elementAt, which throws for an index out of bounds.
325
+ export const getElement = <T>(vector: T[], index: number) => {
326
+ if (index < 0 || index >= vector.length) {
327
+ throw new PcalRuntimeError(`ArrayIndexOutOfBoundsException: ${index}`);
328
+ }
329
+ return vector[index];
330
+ };
331
+
332
+ export const createPcalToken = (string: string, column: number, type: number): PcalToken => ({
333
+ string,
334
+ column,
335
+ type,
336
+ });
337
+
338
+ // TLAToken.getWidth: a string token's width counts its quotes.
339
+ export const getPcalTokenWidth = (token: PcalToken) =>
340
+ token.type === PCAL_TOKEN.string ? token.string.length + 2 : token.string.length;
341
+
342
+ export const createPcalExpr = (tokens: PcalToken[][] = []): PcalExpr => ({
343
+ tokens,
344
+ anchorTokens: undefined,
345
+ anchorTokCol: undefined,
346
+ });
347
+
348
+ // TLAExpr.normalize: drops empty first and last lines, shifts the tokens left as far as they go,
349
+ // and records the token each line is aligned under.
350
+ export const normalizePcalExpr = (expr: PcalExpr) => {
351
+ while (expr.tokens.length > 0 && expr.tokens[0].length === 0) expr.tokens.shift();
352
+ while (expr.tokens.length > 0 && expr.tokens[expr.tokens.length - 1].length === 0) {
353
+ expr.tokens.pop();
354
+ }
355
+ const minColumn = Math.min(
356
+ 999999,
357
+ ...expr.tokens.filter((line) => line.length > 0).map((line) => line[0].column),
358
+ );
359
+ expr.tokens.forEach((line) =>
360
+ line.forEach((token) => {
361
+ token.column -= minColumn;
362
+ }),
363
+ );
364
+ const anchorTokens: (PcalToken | undefined)[] = [];
365
+ const anchorTokCol: number[] = [];
366
+ expr.tokens.forEach((line, index) => {
367
+ anchorTokCol.push(0);
368
+ anchorTokens.push(undefined);
369
+ if (line.length === 0) return;
370
+ const firstColumn = line[0].column;
371
+ const anchorLine = expr.tokens
372
+ .slice(0, index)
373
+ .findLast((candidate) => candidate.length > 0 && candidate[0].column <= firstColumn);
374
+ if (anchorLine === undefined) return;
375
+ const stop = anchorLine.findIndex((token, item) => item > 0 && token.column > firstColumn);
376
+ const anchor = anchorLine[(stop === -1 ? anchorLine.length : stop) - 1];
377
+ anchorTokens[index] = anchor;
378
+ anchorTokCol[index] = anchor.column;
379
+ });
380
+ expr.anchorTokens = anchorTokens;
381
+ expr.anchorTokCol = anchorTokCol;
382
+ };
383
+
384
+ export const createNormalizedPcalExpr = (tokens: PcalToken[][]) => {
385
+ const expr = createPcalExpr(tokens);
386
+ normalizePcalExpr(expr);
387
+ return expr;
388
+ };
389
+
390
+ // TLAExpr.renormalize: shifts each line right by as much as its anchor token has moved.
391
+ const renormalizePcalExpr = (expr: PcalExpr) => {
392
+ const anchorTokens = expr.anchorTokens;
393
+ const anchorTokCol = expr.anchorTokCol;
394
+ if (anchorTokens === undefined || anchorTokCol === undefined) {
395
+ throw new PcalRuntimeError("NullPointerException: TLAExpr.renormalize");
396
+ }
397
+ expr.tokens.forEach((line, index) => {
398
+ const anchor = anchorTokens[index];
399
+ if (anchor === undefined) return;
400
+ const shift = anchor.column - anchorTokCol[index];
401
+ anchorTokCol[index] = anchor.column;
402
+ if (shift < 0) throw new PcalError("TLAExpr.renormalize() found anchor has moved to left.");
403
+ line.forEach((token) => {
404
+ token.column += shift;
405
+ });
406
+ });
407
+ };
408
+
409
+ export const clonePcalExpr = (expr: PcalExpr) =>
410
+ createNormalizedPcalExpr(expr.tokens.map((line) => line.map((token) => ({ ...token }))));
411
+
412
+ // TLAExpr.prepend: puts prefix in front of the expression, spaces columns before its first token.
413
+ export const prependPcalExpr = (expr: PcalExpr, prefix: PcalExpr, spaces: number) => {
414
+ const prefixLines = prefix.tokens.length;
415
+ expr.tokens.splice(0, 0, ...prefix.tokens.slice(0, prefixLines - 1));
416
+ const prefixLine = prefix.tokens[prefixLines - 1];
417
+ const exprLine = expr.tokens[prefixLines - 1];
418
+ const last = prefixLine[prefixLine.length - 1];
419
+ const shift = last.column + getPcalTokenWidth(last) + spaces;
420
+ exprLine.forEach((token) => {
421
+ token.column += shift;
422
+ });
423
+ exprLine.splice(0, 0, ...prefixLine);
424
+ const anchorTokens = [...(prefix.anchorTokens ?? [])];
425
+ const anchorTokCol = [...(prefix.anchorTokCol ?? [])];
426
+ for (let index = prefixLines; index < expr.tokens.length; index++) {
427
+ anchorTokens.push(expr.anchorTokens?.[index - prefixLines + 1]);
428
+ anchorTokCol.push(expr.anchorTokCol?.[index - prefixLines + 1] ?? 0);
429
+ }
430
+ expr.anchorTokens = anchorTokens;
431
+ expr.anchorTokCol = anchorTokCol;
432
+ renormalizePcalExpr(expr);
433
+ };
434
+
435
+ export const isOneTokenPcalExpr = (expr: PcalExpr) =>
436
+ expr.tokens.length === 1 && expr.tokens[0].length === 1;
437
+
438
+ export const getPcalTokenAt = (expr: PcalExpr, coord: PcalCoord) =>
439
+ getElement(getElement(expr.tokens, coord.line), coord.item);
440
+
441
+ // TLAExpr.stepCoord: the coordinates steps tokens after coord, or undefined past the end.
442
+ export const stepPcalCoord = (expr: PcalExpr, coord: PcalCoord, steps: number) => {
443
+ if (expr.tokens.length <= coord.line) {
444
+ throw new PcalBugError("TLAExpr.StepCoord called with line too big");
445
+ }
446
+ if (expr.tokens[coord.line].length <= coord.item) {
447
+ throw new PcalBugError("TLAExpr.StepCoord called with col too big");
448
+ }
449
+ const result = { line: coord.line, item: coord.item };
450
+ for (let step = 0; step < steps; step++) {
451
+ result.item += 1;
452
+ if (expr.tokens[result.line].length === result.item) {
453
+ result.item = 0;
454
+ result.line += 1;
455
+ while (result.line < expr.tokens.length && expr.tokens[result.line].length === 0) {
456
+ result.line += 1;
457
+ }
458
+ if (result.line === expr.tokens.length) return undefined;
459
+ }
460
+ }
461
+ return result;
462
+ };
463
+
464
+ // TLAExpr.findNextInstanceIn: the next token id at or after start that is not a record field
465
+ // name, such as the a in r.a, [a |-> 1] or [a : S].
466
+ const findNextInstance = (expr: PcalExpr, id: string, start: PcalCoord) => {
467
+ for (let coord = expr.tokens.length === 0 ? undefined : { ...start }; coord !== undefined;) {
468
+ const token = getPcalTokenAt(expr, coord);
469
+ const isString = token.type === PCAL_TOKEN.string;
470
+ // The id is an identifier, so a token that is the id is none of the tokens skipped below.
471
+ if (!isString && token.string === id) return coord;
472
+ const afterNext =
473
+ !isString && (token.string === "[" || token.string === ",")
474
+ ? stepPcalCoord(expr, coord, 2)
475
+ : undefined;
476
+ const fieldEnd = afterNext === undefined ? undefined : getPcalTokenAt(expr, afterNext);
477
+ const isFieldName =
478
+ fieldEnd !== undefined &&
479
+ fieldEnd.type !== PCAL_TOKEN.string &&
480
+ [":", "|->", "↦"].includes(fieldEnd.string);
481
+ const steps = isString ? 1 : token.string === "." ? 2 : isFieldName ? 3 : 1;
482
+ coord = stepPcalCoord(expr, coord, steps);
483
+ }
484
+ return undefined;
485
+ };
486
+
487
+ // TLAExpr.substituteAt: replaces the token at coord with a copy of replacement, parenthesized when
488
+ // isParenthesized and replacement has more than one token, and returns the coordinates of the
489
+ // token after it.
490
+ const substituteAt = (
491
+ expr: PcalExpr,
492
+ replacement: PcalExpr,
493
+ coord: PcalCoord,
494
+ isParenthesized: boolean,
495
+ ) => {
496
+ const token = getPcalTokenAt(expr, coord);
497
+ if (isOneTokenPcalExpr(expr)) {
498
+ const cloned = clonePcalExpr(replacement);
499
+ expr.tokens = cloned.tokens;
500
+ expr.anchorTokens = cloned.anchorTokens;
501
+ expr.anchorTokCol = cloned.anchorTokCol;
502
+ return undefined;
503
+ }
504
+ const tokenLine = expr.tokens[coord.line];
505
+ const spaces =
506
+ coord.item + 1 < tokenLine.length
507
+ ? tokenLine[coord.item + 1].column - (token.column + getPcalTokenWidth(token))
508
+ : 0;
509
+ const restOfLine = tokenLine.splice(coord.item + 1);
510
+ // The line the replacement's tokens go on, and how far right they move.
511
+ const cursor = {
512
+ lineIndex: coord.line,
513
+ indent: (isParenthesized ? 1 : 0) + token.column,
514
+ isInserting: !isParenthesized,
515
+ };
516
+ const getLine = () => expr.tokens[cursor.lineIndex];
517
+ if (isOneTokenPcalExpr(replacement)) {
518
+ const replacementToken = replacement.tokens[0][0];
519
+ token.string = replacementToken.string;
520
+ token.type = replacementToken.type;
521
+ } else {
522
+ if (isParenthesized) {
523
+ token.string = "(";
524
+ token.type = PCAL_TOKEN.builtin;
525
+ }
526
+ const newExpr = clonePcalExpr(replacement);
527
+ newExpr.tokens.forEach((replacementLine, index) => {
528
+ replacementLine.forEach((nextToken) => {
529
+ nextToken.column += cursor.indent;
530
+ if (!cursor.isInserting) {
531
+ getLine().push(nextToken);
532
+ return;
533
+ }
534
+ token.string = nextToken.string;
535
+ token.type = nextToken.type;
536
+ cursor.isInserting = false;
537
+ });
538
+ if (index + 1 >= newExpr.tokens.length) return;
539
+ cursor.indent = 0;
540
+ cursor.lineIndex += 1;
541
+ const currentLine = cursor.lineIndex;
542
+ expr.tokens.splice(currentLine, 0, []);
543
+ const oldAnchors = expr.anchorTokens ?? [];
544
+ const oldColumns = expr.anchorTokCol ?? [];
545
+ expr.anchorTokens = expr.tokens.map((_, item) =>
546
+ item < currentLine
547
+ ? oldAnchors[item]
548
+ : item === currentLine
549
+ ? newExpr.anchorTokens?.[index + 1]
550
+ : oldAnchors[item - 1],
551
+ );
552
+ expr.anchorTokCol = expr.tokens.map((_, item) =>
553
+ item < currentLine
554
+ ? oldColumns[item]
555
+ : item === currentLine
556
+ ? (newExpr.anchorTokCol?.[index + 1] ?? 0)
557
+ : oldColumns[item - 1],
558
+ );
559
+ });
560
+ if (isParenthesized) {
561
+ const last = getLine()[getLine().length - 1];
562
+ getLine().push(
563
+ createPcalToken(")", last.column + getPcalTokenWidth(last), PCAL_TOKEN.builtin),
564
+ );
565
+ }
566
+ }
567
+ const line = getLine();
568
+ const result = { line: cursor.lineIndex, item: line.length - 1 };
569
+ if (restOfLine.length > 0) {
570
+ const previous = line[line.length - 1];
571
+ const shift = previous.column + getPcalTokenWidth(previous) + spaces - restOfLine[0].column;
572
+ restOfLine.forEach((oldToken) => {
573
+ oldToken.column += shift;
574
+ line.push(oldToken);
575
+ });
576
+ }
577
+ renormalizePcalExpr(expr);
578
+ return stepPcalCoord(expr, result, 1);
579
+ };
580
+
581
+ // TLAExpr.substituteForAll: replaces each instance of names[i] with exprs[i], in the order the
582
+ // instances appear.
583
+ export const substitutePcalExpr = (
584
+ expr: PcalExpr,
585
+ exprs: PcalExpr[],
586
+ names: string[],
587
+ isParenthesized = true,
588
+ ) => {
589
+ const next = names.map((name) => findNextInstance(expr, name, { line: 0, item: 0 }));
590
+ for (;;) {
591
+ const nearest = next.reduce<{ index: number; position: PcalCoord } | undefined>(
592
+ (best, position, index) =>
593
+ position !== undefined &&
594
+ (best === undefined ||
595
+ position.line < best.position.line ||
596
+ (position.line === best.position.line && position.item < best.position.item))
597
+ ? { index, position }
598
+ : best,
599
+ undefined,
600
+ );
601
+ if (nearest === undefined) return;
602
+ const afterNext = stepPcalCoord(expr, nearest.position, 1);
603
+ const newPosition = substituteAt(expr, exprs[nearest.index], nearest.position, isParenthesized);
604
+ next[nearest.index] =
605
+ newPosition === undefined
606
+ ? undefined
607
+ : findNextInstance(expr, names[nearest.index], newPosition);
608
+ next.forEach((position, index) => {
609
+ if (index === nearest.index || position === undefined || newPosition === undefined) return;
610
+ // HACK: TLAExpr.substituteForAll dereferences afterNextPos without checking for null, which
611
+ // throws a NullPointerException when the substituted token ends the expression.
612
+ if (afterNext === undefined) {
613
+ throw new PcalRuntimeError("NullPointerException: TLAExpr.substituteForAll");
614
+ }
615
+ if (position.line === nearest.position.line)
616
+ position.item += newPosition.item - afterNext.item;
617
+ position.line += newPosition.line - afterNext.line;
618
+ });
619
+ }
620
+ };
621
+
622
+ export const getSubstitutedPcalExpr = (expr: PcalExpr, args: PcalExpr[], params: string[]) => {
623
+ const result = clonePcalExpr(expr);
624
+ substitutePcalExpr(result, args, params);
625
+ return result;
626
+ };
627
+
628
+ // TLAExpr.SeqSubstituteForAll.
629
+ export const substitutePcalExprs = (exprs: PcalExpr[], args: PcalExpr[], params: string[]) =>
630
+ exprs.map((expr) => getSubstitutedPcalExpr(expr, args, params));
631
+
632
+ // TLAExpr.toString, which names the column of a junction except in TLC 1.7.4.
633
+ const formatPcalExpr = (expr: PcalExpr, version?: TlcVersion) => {
634
+ const getColumn = (token: PcalToken) => (version === "1.7.4" ? "" : `(col${token.column}) `);
635
+ const tokens = expr.tokens.map((line) =>
636
+ line.map((token) => {
637
+ if (token.type === PCAL_TOKEN.string) return `"\\"", "${token.string}", "\\""`;
638
+ if (token.string === "\\/") return `"${getColumn(token)}\\\\/"`;
639
+ if (token.string.startsWith("\\")) return `"\\${token.string}"`;
640
+ if (token.string === "/\\") return `"${getColumn(token)}/\\\\"`;
641
+ return `"${token.string}"`;
642
+ }),
643
+ );
644
+ const firstTokenLine = tokens.findIndex((line) => line.length > 0);
645
+ const text = tokens
646
+ .map((line, index) => {
647
+ const isAfterToken = firstTokenLine !== -1 && index > firstTokenLine;
648
+ return line.map((token, item) => (isAfterToken || item > 0 ? `, ${token}` : token)).join("");
649
+ })
650
+ .join("\n");
651
+ return `<< ${text} >>`;
652
+ };
653
+
654
+ // AST.toString: the TLA+ record that PlusCal.tla uses for the node. Indent, EndIndent and NewLine
655
+ // keep a stack of indentation columns as the Java concatenates the record's text left to right.
656
+ export const formatPcalNode = (
657
+ node: PcalNode,
658
+ inputVersionNumber: number,
659
+ version?: TlcVersion,
660
+ ) => {
661
+ const formatExpr = (expr: PcalExpr) => formatPcalExpr(expr, version);
662
+ const columns = [0];
663
+ const depth = { value: 0 };
664
+ const indent = (text: string) => {
665
+ columns[depth.value + 1] = columns[depth.value] + text.length;
666
+ depth.value += 1;
667
+ return text;
668
+ };
669
+ const endIndent = () => {
670
+ depth.value -= 1;
671
+ return "";
672
+ };
673
+ const newLine = () => `\n${" ".repeat(columns[depth.value])}`;
674
+ const isOldVersion = inputVersionNumber < 1500;
675
+ // The separators' new lines take the indentation the elements before them leave.
676
+ const formatSeq = (vector: (PcalNode | PcalExpr)[]) =>
677
+ `${indent("<<")}${vector
678
+ .map(
679
+ (element, index) =>
680
+ `${index > 0 ? `, ${newLine()}` : ""}${"kind" in element ? format(element) : formatExpr(element)}`,
681
+ )
682
+ .join("")}>>${endIndent()}`;
683
+ const formatQuotedSeq = (vector: string[]) =>
684
+ `${indent("<<")}${vector.map((element) => `"${element}"`).join(", ")}>>${endIndent()}`;
685
+ const formatSeqOfSeqs = (vectors: PcalStmt[][]) =>
686
+ `${indent("<< ")}${vectors
687
+ .map((vector, index) => `${index > 0 ? `, ${newLine()}` : ""}${formatSeq(vector)}`)
688
+ .join("")} >>${endIndent()}`;
689
+ const formatEqOrIn = (isEq: boolean) => (isEq ? '"="' : '"\\\\in"');
690
+ const format = (node: PcalNode): string => {
691
+ switch (node.kind) {
692
+ case "Uniprocess":
693
+ return `${indent("")}[type |-> "uniprocess", ${newLine()} name |-> "${node.name}", ${newLine()}${indent(" decls |-> ")}${formatSeq(node.decls)},${endIndent()}${newLine()}${indent(" defs |-> ")}${formatExpr(node.defs)},${endIndent()}${newLine()}${indent(" prcds |-> ")}${formatSeq(node.prcds)},${endIndent()}${newLine()}${indent(" body |-> ")}${formatSeq(node.body)}]${endIndent()}${endIndent()}`;
694
+ case "Multiprocess":
695
+ return `${indent("")}[type |-> "multiprocess", ${newLine()} name |-> "${node.name}", ${newLine()}${indent(" decls |-> ")}${formatSeq(node.decls)},${endIndent()}${newLine()}${indent(" defs |-> ")}${formatExpr(node.defs)},${endIndent()}${newLine()}${indent(" prcds |-> ")}${formatSeq(node.prcds)},${endIndent()}${newLine()}${indent(" procs |-> ")}${formatSeq(node.procs)}]${endIndent()}${endIndent()}`;
696
+ case "Procedure":
697
+ return isOldVersion
698
+ ? `${indent("")}[name |-> "${node.name}", ${newLine()}${indent(" params |-> ")}${formatSeq(node.params)},${endIndent()}${newLine()}${indent(" decls |-> ")}${formatSeq(node.decls)},${endIndent()}${newLine()}${indent(" body |-> ")}${formatSeq(node.body)}]${endIndent()}${endIndent()}`
699
+ : `${indent("")}[name |-> "${node.name}", ${newLine()}minusLabels |-> ${formatQuotedSeq(node.minusLabels)}, plusLabels |->${formatQuotedSeq(node.plusLabels)}, proceduresCalled |->${formatQuotedSeq(node.proceduresCalled)},${newLine()}${indent(" params |-> ")}${formatSeq(node.params)},${endIndent()}${newLine()}${indent(" decls |-> ")}${formatSeq(node.decls)},${endIndent()}${newLine()}${indent(" body |-> ")}${formatSeq(node.body)}]${endIndent()}${endIndent()}`;
700
+ case "Process":
701
+ return isOldVersion
702
+ ? `${indent("")}[name |-> "${node.name}", ${newLine()} eqOrIn |-> ${formatEqOrIn(node.isEq)},${newLine()} id |-> ${formatExpr(node.id)},${newLine()}${indent(" decls |-> ")}${formatSeq(node.decls)},${endIndent()}${newLine()}${indent(" body |-> ")}${formatSeq(node.body)}]${endIndent()}${endIndent()}`
703
+ : `${indent("")}[name |-> "${node.name}",${newLine()} fairness |-> "${PCAL_FAIRNESS[node.fairness]}", minusLabels |-> ${formatQuotedSeq(node.minusLabels)}, plusLabels |->${formatQuotedSeq(node.plusLabels)}, proceduresCalled |->${formatQuotedSeq(node.proceduresCalled)},${newLine()} eqOrIn |-> ${formatEqOrIn(node.isEq)},${newLine()} id |-> ${formatExpr(node.id)},${newLine()}${indent(" decls |-> ")}${formatSeq(node.decls)},${endIndent()}${newLine()}${indent(" body |-> ")}${formatSeq(node.body)}]${endIndent()}${endIndent()}`;
704
+ case "VarDecl":
705
+ return `${indent("")}[var |-> "${node.var}", eqOrIn |-> ${formatEqOrIn(node.isEq)}, val |-> ${formatExpr(node.val)}]${endIndent()}`;
706
+ case "PVarDecl":
707
+ return `${indent("")}[var |-> "${node.var}", eqOrIn |-> "=", val |-> ${formatExpr(node.val)}]${endIndent()}`;
708
+ case "LabeledStmt":
709
+ return `${indent("")}[label |-> "${node.label}",${newLine()}${indent(" stmts |-> ")}${formatSeq(node.stmts)}]${endIndent()}${endIndent()}`;
710
+ case "While":
711
+ return `${indent("")}[type |-> "while", ${newLine()} test |-> ${formatExpr(node.test)},${newLine()}${indent(" labDo |-> ")}${formatSeq(node.labDo)},${endIndent()}${newLine()}${indent(" unlabDo |-> ")}${formatSeq(node.unlabDo)}]${endIndent()}${endIndent()}`;
712
+ case "Assign":
713
+ return `${indent("")}[type |-> "assignment",${newLine()}${indent(" ass |-> ")}${formatSeq(node.ass)}]${endIndent()}${endIndent()}`;
714
+ case "SingleAssign":
715
+ return `${indent("")}[lhs |-> ${format(node.lhs)},${newLine()} rhs |-> ${formatExpr(node.rhs)}]${endIndent()}`;
716
+ case "Lhs":
717
+ return `[var |-> "${node.var}", sub |-> ${formatExpr(node.sub)}]`;
718
+ case "If":
719
+ return `${indent("")}[type |-> "if", ${newLine()} test |-> ${formatExpr(node.test)},${newLine()}${indent(" then |-> ")}${formatSeq(node.Then)},${endIndent()}${newLine()}${indent(" else |-> ")}${formatSeq(node.Else)}]${endIndent()}${endIndent()}`;
720
+ case "Either":
721
+ return `${indent("")}[type |-> "either", ${newLine()}${indent(" ors |-> ")}${formatSeqOfSeqs(node.ors)}]${endIndent()}${endIndent()}`;
722
+ case "With":
723
+ return `${indent("")}[type |-> "with", ${newLine()} var |-> "${node.var}",${newLine()} eqOrIn |-> ${formatEqOrIn(node.isEq)},${newLine()} exp |-> ${formatExpr(node.exp)},${newLine()}${indent(" do |-> ")}${formatSeq(node.Do)}]${endIndent()}${endIndent()}`;
724
+ case "When":
725
+ return `${indent("")}[type |-> "when", ${newLine()} exp |-> ${formatExpr(node.exp)}]${endIndent()}`;
726
+ case "PrintS":
727
+ return `${indent("")}[type |-> "print", ${newLine()} exp |-> ${formatExpr(node.exp)}]${endIndent()}`;
728
+ case "Assert":
729
+ return `${indent("")}[type |-> "assert", ${newLine()} exp |-> ${formatExpr(node.exp)}]${endIndent()}`;
730
+ case "Skip":
731
+ return '[type |-> "skip"]';
732
+ case "LabelIf":
733
+ return `${indent("")}[type |-> "labelIf",${newLine()} test |-> ${formatExpr(node.test)},${newLine()}${indent(" unlabThen |-> ")}${formatSeq(node.unlabThen)},${endIndent()}${newLine()}${indent(" labThen |-> ")}${formatSeq(node.labThen)},${endIndent()}${newLine()}${indent(" unlabElse |-> ")}${formatSeq(node.unlabElse)},${endIndent()}${newLine()}${indent(" labElse |-> ")}${formatSeq(node.labElse)}]${endIndent()}${newLine()}${endIndent()}`;
734
+ case "LabelEither":
735
+ return `${indent("")}[type |-> "labelEither",${newLine()}${indent(" clauses |-> ")}${formatSeq(node.clauses)}]${endIndent()}${newLine()}${endIndent()}`;
736
+ case "Clause":
737
+ return `${indent("")}${indent("[unlabOr |-> ")}${formatSeq(node.unlabOr)},${endIndent()}${newLine()}${indent(" labOr |-> ")}${formatSeq(node.labOr)}]${endIndent()}${newLine()}${endIndent()}`;
738
+ case "Call":
739
+ return `${indent("")}[type |-> "call",${newLine()} returnTo |-> "${node.returnTo}",${newLine()} to |-> "${node.to}",${newLine()}${indent(" args |-> ")}${formatSeq(node.args)}]${endIndent()}${endIndent()}`;
740
+ case "Return":
741
+ return `[type |-> "return", from |-> "${node.from ?? "null"}"]`;
742
+ case "CallReturn":
743
+ return `${indent("")}[type |-> "callReturn",${newLine()} from |-> "${node.from ?? "null"}",${newLine()} to |-> "${node.to}",${newLine()}${indent("args |-> ")}${formatSeq(node.args)}]${newLine()}${endIndent()}${endIndent()}`;
744
+ case "CallGoto":
745
+ return `${indent("")}[type |-> "callGoto",${newLine()} after |-> "${node.after}",${newLine()} to |-> "${node.to}",${newLine()}${indent("args |-> ")}${formatSeq(node.args)}]${newLine()}${endIndent()}${endIndent()}`;
746
+ case "Goto":
747
+ return `[type |-> "goto", to |-> "${node.to}"]`;
748
+ case "Macro":
749
+ return `${indent("")}[name |-> "${node.name}", ${newLine()}${indent(" params |-> ")}${indent("<<")}${node.params.join(`, ${newLine()}`)}>>${endIndent()},${endIndent()}${newLine()}${indent(" body |-> ")}${formatSeq(node.body)}]${endIndent()}${endIndent()}`;
750
+ case "MacroCall":
751
+ return `${indent("")}[type |-> "macrocall",${newLine()} name |-> "${node.name}",${newLine()}${indent(" args |-> ")}${formatSeq(node.args)}]${endIndent()}${endIndent()}`;
752
+ }
753
+ };
754
+ return format(node);
755
+ };