tla-ts 0.0.10-dev.f16792fed → 0.0.10-dev.fdc173479

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 (587) hide show
  1. package/README.md +2 -1
  2. package/dist/compile.cjs +6 -6
  3. package/dist/compile.js +10 -10
  4. package/dist/deciders.cjs +41 -37
  5. package/dist/deciders.js +41 -37
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +21 -4
  8. package/dist/index.d.ts +21 -4
  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 +2681 -425
  15. package/dist/prove.js +2681 -425
  16. package/dist/run.cjs +41 -42
  17. package/dist/run.js +41 -42
  18. package/dist/tlapm.cjs +2 -2
  19. package/dist/tlapm.js +2 -2
  20. package/dist/transfer.cjs +97 -89
  21. package/dist/transfer.js +97 -89
  22. package/dist/worker.cjs +7 -7
  23. package/dist/worker.js +7 -7
  24. package/package.json +1 -1
  25. package/src/ast.ts +72 -39
  26. package/src/bags.ts +50 -29
  27. package/src/builtins.ts +8 -16
  28. package/src/check-failure.ts +118 -0
  29. package/src/check-trace.ts +321 -0
  30. package/src/check.ts +828 -770
  31. package/src/cli/options.ts +6 -31
  32. package/src/cli/runtime-invariants.ts +20 -56
  33. package/src/cli/shared.ts +1 -1
  34. package/src/cli/tlapm.ts +433 -70
  35. package/src/cli/tlc-arguments.ts +224 -212
  36. package/src/cli/tlc-output.ts +701 -0
  37. package/src/cli/tlc-usage.ts +1 -2
  38. package/src/cli/tlc.ts +65 -712
  39. package/src/cli/xml-exporter.ts +23 -33
  40. package/src/codegen.ts +28 -20
  41. package/src/coverage.ts +255 -20
  42. package/src/dependencies.ts +96 -27
  43. package/src/dfid.ts +115 -50
  44. package/src/environment-config.ts +315 -0
  45. package/src/environment.ts +175 -373
  46. package/src/errors.ts +40 -5
  47. package/src/evaluate.ts +429 -139
  48. package/src/exit-codes.ts +28 -12
  49. package/src/fingerprints.ts +65 -1
  50. package/src/instances.ts +178 -17
  51. package/src/java-hash.ts +14 -0
  52. package/src/java-overrides.ts +2 -2
  53. package/src/json.ts +4 -7
  54. package/src/levels.ts +708 -272
  55. package/src/lexer.ts +17 -5
  56. package/src/liveness-checker.ts +707 -249
  57. package/src/liveness.ts +148 -95
  58. package/src/obligations/action.ts +14 -17
  59. package/src/obligations/anonymize.ts +37 -16
  60. package/src/obligations/enabled-axioms.ts +218 -0
  61. package/src/obligations/equality.ts +1 -3
  62. package/src/obligations/expression.ts +36 -8
  63. package/src/obligations/format.ts +0 -2
  64. package/src/obligations/generate.ts +66 -54
  65. package/src/obligations/index.ts +39 -9
  66. package/src/obligations/levels.ts +24 -11
  67. package/src/obligations/module.ts +28 -41
  68. package/src/obligations/normalize.ts +27 -18
  69. package/src/obligations/operators.ts +0 -2
  70. package/src/obligations/pragma.ts +53 -16
  71. package/src/obligations/printer.ts +48 -18
  72. package/src/obligations/proof.ts +3 -2
  73. package/src/obligations/regroup.ts +0 -2
  74. package/src/obligations/simplify.ts +55 -50
  75. package/src/obligations/source.ts +120 -74
  76. package/src/obligations/subexpression.ts +45 -18
  77. package/src/obligations/substitution.ts +1 -3
  78. package/src/obligations/temporal.ts +5 -7
  79. package/src/obligations/tuples.ts +0 -2
  80. package/src/parallel-worker.ts +17 -31
  81. package/src/parallel.ts +29 -47
  82. package/src/parser.ts +757 -326
  83. package/src/pretty-print.ts +1 -1
  84. package/src/prover/decide-pool.ts +3 -3
  85. package/src/prover/deciders.ts +12 -9
  86. package/src/prover/isabelle/decide.ts +3 -25
  87. package/src/prover/isabelle/encode.ts +72 -42
  88. package/src/prover/isabelle/isar/attrib.ts +250 -0
  89. package/src/prover/isabelle/isar/context.ts +335 -0
  90. package/src/prover/isabelle/isar/induct.ts +382 -0
  91. package/src/prover/isabelle/isar/inner-syntax.ts +158 -7
  92. package/src/prover/isabelle/isar/method.ts +509 -212
  93. package/src/prover/isabelle/isar/proof.ts +570 -14
  94. package/src/prover/isabelle/isar/rule-cases.ts +226 -0
  95. package/src/prover/isabelle/isar/theory.ts +487 -76
  96. package/src/prover/isabelle/isar/toplevel.ts +331 -0
  97. package/src/prover/isabelle/isar/type-check.ts +89 -14
  98. package/src/prover/isabelle/provers/blast/blast.ts +7 -65
  99. package/src/prover/isabelle/provers/blast/branch.ts +0 -2
  100. package/src/prover/isabelle/provers/blast/prove.ts +0 -2
  101. package/src/prover/isabelle/provers/blast/rules.ts +0 -2
  102. package/src/prover/isabelle/provers/blast/state.ts +0 -2
  103. package/src/prover/isabelle/provers/blast/term.ts +0 -2
  104. package/src/prover/isabelle/provers/clasimp.ts +1 -3
  105. package/src/prover/isabelle/provers/classical.ts +45 -20
  106. package/src/prover/isabelle/provers/hypsubst.ts +19 -30
  107. package/src/prover/isabelle/pure/bicompose.ts +9 -27
  108. package/src/prover/isabelle/pure/consts.ts +0 -2
  109. package/src/prover/isabelle/pure/conv.ts +2 -10
  110. package/src/prover/isabelle/pure/drule.ts +72 -6
  111. package/src/prover/isabelle/pure/envir.ts +0 -2
  112. package/src/prover/isabelle/pure/goal.ts +1 -3
  113. package/src/prover/isabelle/pure/logic.ts +1 -3
  114. package/src/prover/isabelle/pure/name.ts +0 -2
  115. package/src/prover/isabelle/pure/net.ts +0 -2
  116. package/src/prover/isabelle/pure/object-logic.ts +13 -7
  117. package/src/prover/isabelle/pure/pattern.ts +0 -2
  118. package/src/prover/isabelle/pure/raw-simplifier.ts +4 -15
  119. package/src/prover/isabelle/pure/rewriter.ts +9 -20
  120. package/src/prover/isabelle/pure/search.ts +0 -2
  121. package/src/prover/isabelle/pure/seq.ts +0 -2
  122. package/src/prover/isabelle/pure/simplifier.ts +26 -7
  123. package/src/prover/isabelle/pure/table.ts +2 -3
  124. package/src/prover/isabelle/pure/tactic.ts +0 -2
  125. package/src/prover/isabelle/pure/tactical.ts +42 -37
  126. package/src/prover/isabelle/pure/term-ord.ts +0 -2
  127. package/src/prover/isabelle/pure/term.ts +3 -5
  128. package/src/prover/isabelle/pure/thm.ts +14 -13
  129. package/src/prover/isabelle/pure/type.ts +0 -2
  130. package/src/prover/isabelle/pure/unify.ts +0 -2
  131. package/src/prover/isabelle/pure/variable.ts +0 -2
  132. package/src/prover/isabelle/tla/classical-setup.ts +18 -16
  133. package/src/prover/isabelle/tla/context.ts +58 -11
  134. package/src/prover/isabelle/tla/logic-data.ts +1 -1
  135. package/src/prover/isabelle/tla/logic.ts +49 -21
  136. package/src/prover/isabelle/tla/simpdata.ts +1 -12
  137. package/src/prover/isabelle/tools/intuitionistic.ts +28 -12
  138. package/src/prover/ocaml.ts +4 -1
  139. package/src/prover/prep/action.ts +30 -31
  140. package/src/prover/prep/enabled-axioms.ts +11 -2
  141. package/src/prover/prep/fingerprint.ts +2 -5
  142. package/src/prover/prep/md5.ts +26 -29
  143. package/src/prover/prep/methods.ts +181 -51
  144. package/src/prover/prep/normalize.ts +38 -9
  145. package/src/prover/prove.ts +395 -94
  146. package/src/prover/ptl/decide.ts +95 -50
  147. package/src/prover/ptl/encode.ts +2 -3
  148. package/src/prover/ptl/tableau.ts +28 -2
  149. package/src/prover/smt/arithmetic.ts +310 -0
  150. package/src/prover/smt/axioms.ts +12 -8
  151. package/src/prover/smt/context.ts +43 -8
  152. package/src/prover/smt/data.ts +498 -379
  153. package/src/prover/smt/encode.ts +148 -57
  154. package/src/prover/smt/extensionality.ts +5 -3
  155. package/src/prover/smt/flatten.ts +4 -6
  156. package/src/prover/smt/format.ts +28 -4
  157. package/src/prover/smt/instances.ts +7 -1
  158. package/src/prover/smt/layout.ts +91 -0
  159. package/src/prover/smt/rewrite.ts +1016 -618
  160. package/src/prover/smt/simplify.ts +441 -0
  161. package/src/prover/smt/solver/ackermannize-bv-tactic.ts +62 -0
  162. package/src/prover/smt/solver/ackr-helper.ts +179 -0
  163. package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
  164. package/src/prover/smt/solver/act-cache.ts +0 -1
  165. package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
  166. package/src/prover/smt/solver/aig-tactic.ts +52 -0
  167. package/src/prover/smt/solver/aig.ts +889 -0
  168. package/src/prover/smt/solver/arith-rewriter.ts +624 -9
  169. package/src/prover/smt/solver/arith-terms.ts +121 -0
  170. package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
  171. package/src/prover/smt/solver/array-rewriter.ts +319 -0
  172. package/src/prover/smt/solver/asserted-formulas.ts +240 -56
  173. package/src/prover/smt/solver/ast-lt.ts +165 -11
  174. package/src/prover/smt/solver/ast-util.ts +160 -2
  175. package/src/prover/smt/solver/ast.ts +1483 -45
  176. package/src/prover/smt/solver/auf-solver.ts +25 -18
  177. package/src/prover/smt/solver/bit-blast-tactic.ts +608 -0
  178. package/src/prover/smt/solver/bit-blaster.ts +871 -0
  179. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  180. package/src/prover/smt/solver/bound-manager.ts +196 -0
  181. package/src/prover/smt/solver/bound-simplifier.ts +598 -0
  182. package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
  183. package/src/prover/smt/solver/bv-decl-plugin.ts +341 -0
  184. package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
  185. package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
  186. package/src/prover/smt/solver/bv1-blast.ts +214 -0
  187. package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
  188. package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
  189. package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
  190. package/src/prover/smt/solver/card2bv.ts +127 -0
  191. package/src/prover/smt/solver/case-split-queue.ts +0 -2
  192. package/src/prover/smt/solver/cg-table.ts +39 -25
  193. package/src/prover/smt/solver/check-logic.ts +330 -0
  194. package/src/prover/smt/solver/clause.ts +0 -1
  195. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +293 -0
  196. package/src/prover/smt/solver/conflict-resolution.ts +78 -2
  197. package/src/prover/smt/solver/context.ts +598 -128
  198. package/src/prover/smt/solver/ctx-simplify.ts +29 -14
  199. package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
  200. package/src/prover/smt/solver/datatype-decl-plugin.ts +580 -0
  201. package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
  202. package/src/prover/smt/solver/demodulator.ts +786 -0
  203. package/src/prover/smt/solver/dependent-expr-state.ts +93 -0
  204. package/src/prover/smt/solver/der.ts +38 -10
  205. package/src/prover/smt/solver/diff-neq.ts +207 -0
  206. package/src/prover/smt/solver/distribute-forall.ts +57 -0
  207. package/src/prover/smt/solver/dom-simplify.ts +511 -0
  208. package/src/prover/smt/solver/dt2bv-tactic.ts +298 -0
  209. package/src/prover/smt/solver/dyn-ack.ts +0 -1
  210. package/src/prover/smt/solver/e-matching.ts +7 -8
  211. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  212. package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
  213. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  214. package/src/prover/smt/solver/elim-uncnstr.ts +548 -0
  215. package/src/prover/smt/solver/enode.ts +100 -3
  216. package/src/prover/smt/solver/eq2bv-tactic.ts +227 -0
  217. package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
  218. package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
  219. package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
  220. package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
  221. package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
  222. package/src/prover/smt/solver/euf/array-solver.ts +306 -0
  223. package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
  224. package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
  225. package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
  226. package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
  227. package/src/prover/smt/solver/euf/egraph.ts +901 -0
  228. package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
  229. package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
  230. package/src/prover/smt/solver/euf/mam.ts +1046 -0
  231. package/src/prover/smt/solver/euf/q-ematch.ts +829 -0
  232. package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
  233. package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
  234. package/src/prover/smt/solver/euf/q-solver.ts +361 -0
  235. package/src/prover/smt/solver/euf/th-solver.ts +328 -0
  236. package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
  237. package/src/prover/smt/solver/expr-ref.ts +0 -1
  238. package/src/prover/smt/solver/expr-safe-replace.ts +26 -2
  239. package/src/prover/smt/solver/expr2polynomial.ts +271 -0
  240. package/src/prover/smt/solver/factor.ts +163 -0
  241. package/src/prover/smt/solver/fd-solver.ts +734 -0
  242. package/src/prover/smt/solver/fingerprints.ts +15 -15
  243. package/src/prover/smt/solver/fix-dl-var.ts +147 -0
  244. package/src/prover/smt/solver/flat-literals.ts +0 -1
  245. package/src/prover/smt/solver/fm-tactic.ts +886 -0
  246. package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
  247. package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
  248. package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
  249. package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
  250. package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
  251. package/src/prover/smt/solver/goal.ts +178 -15
  252. package/src/prover/smt/solver/goal2nlsat.ts +216 -0
  253. package/src/prover/smt/solver/guard-set.ts +219 -0
  254. package/src/prover/smt/solver/hash.ts +0 -1
  255. package/src/prover/smt/solver/hashtable.ts +34 -16
  256. package/src/prover/smt/solver/inf-eps.ts +63 -0
  257. package/src/prover/smt/solver/inj-axiom.ts +101 -0
  258. package/src/prover/smt/solver/internalizer.ts +111 -39
  259. package/src/prover/smt/solver/lackr.ts +381 -0
  260. package/src/prover/smt/solver/lbool.ts +0 -1
  261. package/src/prover/smt/solver/lia2card.ts +268 -0
  262. package/src/prover/smt/solver/lia2pb.ts +154 -0
  263. package/src/prover/smt/solver/literal.ts +0 -1
  264. package/src/prover/smt/solver/logic-tactics.ts +355 -0
  265. package/src/prover/smt/solver/lp/bound-propagator.ts +0 -1
  266. package/src/prover/smt/solver/lp/constraints.ts +0 -1
  267. package/src/prover/smt/solver/lp/containers.ts +7 -2
  268. package/src/prover/smt/solver/lp/core-solver.ts +30 -11
  269. package/src/prover/smt/solver/lp/cross-nested.ts +1 -4
  270. package/src/prover/smt/solver/lp/dep-intervals.ts +0 -3
  271. package/src/prover/smt/solver/lp/dependency.ts +0 -2
  272. package/src/prover/smt/solver/lp/dioph-eq.ts +1 -10
  273. package/src/prover/smt/solver/lp/explanation.ts +0 -1
  274. package/src/prover/smt/solver/lp/gomory.ts +0 -1
  275. package/src/prover/smt/solver/lp/hnf-cutter.ts +1 -2
  276. package/src/prover/smt/solver/lp/hnf.ts +0 -3
  277. package/src/prover/smt/solver/lp/int-cube.ts +3 -4
  278. package/src/prover/smt/solver/lp/int-solver.ts +0 -2
  279. package/src/prover/smt/solver/lp/lar-solver.ts +41 -5
  280. package/src/prover/smt/solver/lp/lar-term.ts +0 -1
  281. package/src/prover/smt/solver/lp/lp-settings.ts +6 -3
  282. package/src/prover/smt/solver/lp/maximize-term.ts +59 -10
  283. package/src/prover/smt/solver/lp/nex-creator.ts +3 -3
  284. package/src/prover/smt/solver/lp/nex.ts +2 -2
  285. package/src/prover/smt/solver/lp/nla-backoff.ts +0 -2
  286. package/src/prover/smt/solver/lp/nla-basics.ts +46 -3
  287. package/src/prover/smt/solver/lp/nla-core.ts +68 -17
  288. package/src/prover/smt/solver/lp/nla-divisions.ts +0 -2
  289. package/src/prover/smt/solver/lp/nla-emonics.ts +0 -1
  290. package/src/prover/smt/solver/lp/nla-factorization.ts +0 -1
  291. package/src/prover/smt/solver/lp/nla-grobner.ts +167 -85
  292. package/src/prover/smt/solver/lp/nla-horner.ts +0 -2
  293. package/src/prover/smt/solver/lp/nla-intervals.ts +0 -1
  294. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +0 -2
  295. package/src/prover/smt/solver/lp/nla-monotone.ts +0 -1
  296. package/src/prover/smt/solver/lp/nla-order.ts +0 -2
  297. package/src/prover/smt/solver/lp/nla-patcher.ts +0 -1
  298. package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
  299. package/src/prover/smt/solver/lp/nla-tangents.ts +0 -2
  300. package/src/prover/smt/solver/lp/nla-throttle.ts +0 -1
  301. package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
  302. package/src/prover/smt/solver/lp/nla-types.ts +0 -2
  303. package/src/prover/smt/solver/lp/nla-var-eqs.ts +0 -1
  304. package/src/prover/smt/solver/lp/nra-solver.ts +163 -99
  305. package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
  306. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -3
  307. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -21
  308. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -41
  309. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  310. package/src/prover/smt/solver/lp/random-updater.ts +0 -2
  311. package/src/prover/smt/solver/lp/static-matrix.ts +0 -1
  312. package/src/prover/smt/solver/lp/union-find.ts +7 -2
  313. package/src/prover/smt/solver/macro-finder.ts +530 -0
  314. package/src/prover/smt/solver/mam-compiler.ts +122 -90
  315. package/src/prover/smt/solver/mam-interpreter.ts +0 -1
  316. package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
  317. package/src/prover/smt/solver/max-cliques.ts +105 -0
  318. package/src/prover/smt/solver/maxcore.ts +310 -0
  319. package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -6
  320. package/src/prover/smt/solver/maxlex.ts +115 -0
  321. package/src/prover/smt/solver/maxsmt-base.ts +106 -0
  322. package/src/prover/smt/solver/maxsmt.ts +92 -0
  323. package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
  324. package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
  325. package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
  326. package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
  327. package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
  328. package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
  329. package/src/prover/smt/solver/model-based-opt.ts +844 -0
  330. package/src/prover/smt/solver/model-checker.ts +19 -28
  331. package/src/prover/smt/solver/model-evaluator.ts +190 -12
  332. package/src/prover/smt/solver/model-finder.ts +12 -18
  333. package/src/prover/smt/solver/model-generator.ts +104 -35
  334. package/src/prover/smt/solver/model-macro-solver.ts +49 -46
  335. package/src/prover/smt/solver/model-printer.ts +214 -0
  336. package/src/prover/smt/solver/mpf.ts +709 -0
  337. package/src/prover/smt/solver/mus.ts +50 -0
  338. package/src/prover/smt/solver/muz/dl-context.ts +382 -0
  339. package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
  340. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
  341. package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
  342. package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
  343. package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
  344. package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
  345. package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
  346. package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
  347. package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
  348. package/src/prover/smt/solver/muz/dl-rule.ts +495 -0
  349. package/src/prover/smt/solver/muz/hnf.ts +201 -0
  350. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
  351. package/src/prover/smt/solver/muz/horn-tactic.ts +214 -0
  352. package/src/prover/smt/solver/muz/rule-properties.ts +359 -0
  353. package/src/prover/smt/solver/muz/spacer-context.ts +1404 -0
  354. package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
  355. package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
  356. package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
  357. package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
  358. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
  359. package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
  360. package/src/prover/smt/solver/muz/substitution.ts +203 -0
  361. package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
  362. package/src/prover/smt/solver/nlqsat.ts +485 -0
  363. package/src/prover/smt/solver/nlsat/algebraic.ts +315 -98
  364. package/src/prover/smt/solver/nlsat/atoms.ts +71 -38
  365. package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
  366. package/src/prover/smt/solver/nlsat/explain.ts +427 -229
  367. package/src/prover/smt/solver/nlsat/interval-set.ts +1 -2
  368. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -246
  369. package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
  370. package/src/prover/smt/solver/nlsat/polynomial.ts +2376 -684
  371. package/src/prover/smt/solver/nlsat/solver.ts +293 -92
  372. package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
  373. package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
  374. package/src/prover/smt/solver/nlsat/types.ts +0 -2
  375. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +9 -8
  376. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -20
  377. package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
  378. package/src/prover/smt/solver/nnf.ts +110 -24
  379. package/src/prover/smt/solver/normalize-bounds.ts +53 -0
  380. package/src/prover/smt/solver/occf.ts +97 -0
  381. package/src/prover/smt/solver/opt-context.ts +801 -0
  382. package/src/prover/smt/solver/opt-nlsat.ts +386 -0
  383. package/src/prover/smt/solver/opt-pareto.ts +301 -0
  384. package/src/prover/smt/solver/opt-preprocess.ts +101 -0
  385. package/src/prover/smt/solver/opt-solver.ts +312 -0
  386. package/src/prover/smt/solver/opt-value.ts +55 -0
  387. package/src/prover/smt/solver/optsmt.ts +692 -0
  388. package/src/prover/smt/solver/parallel-tactic.ts +299 -0
  389. package/src/prover/smt/solver/pattern-inference.ts +19 -11
  390. package/src/prover/smt/solver/pb-rewriter.ts +281 -0
  391. package/src/prover/smt/solver/pb2bv-tactic.ts +546 -0
  392. package/src/prover/smt/solver/poly-rewriter.ts +259 -57
  393. package/src/prover/smt/solver/probes.ts +577 -0
  394. package/src/prover/smt/solver/propagate-values.ts +37 -21
  395. package/src/prover/smt/solver/proto-model.ts +648 -19
  396. package/src/prover/smt/solver/pull-quant.ts +28 -12
  397. package/src/prover/smt/solver/purify-arith.ts +634 -0
  398. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  399. package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -0
  400. package/src/prover/smt/solver/qe-lite-der.ts +2 -3
  401. package/src/prover/smt/solver/qe-lite-fm.ts +3 -4
  402. package/src/prover/smt/solver/qe-lite.ts +39 -19
  403. package/src/prover/smt/solver/qe-mbp.ts +270 -0
  404. package/src/prover/smt/solver/qe.ts +1499 -0
  405. package/src/prover/smt/solver/qel.ts +25 -0
  406. package/src/prover/smt/solver/qi-queue.ts +0 -1
  407. package/src/prover/smt/solver/qsat.ts +829 -0
  408. package/src/prover/smt/solver/quant-hoist.ts +196 -0
  409. package/src/prover/smt/solver/quant-tactics.ts +16 -56
  410. package/src/prover/smt/solver/quantifier-analyzer.ts +19 -20
  411. package/src/prover/smt/solver/quantifier-manager.ts +22 -25
  412. package/src/prover/smt/solver/quasi-macros.ts +243 -0
  413. package/src/prover/smt/solver/random-gen.ts +0 -1
  414. package/src/prover/smt/solver/rational.ts +45 -1
  415. package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -0
  416. package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
  417. package/src/prover/smt/solver/reduce-args.ts +225 -0
  418. package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
  419. package/src/prover/smt/solver/ref-vector.ts +0 -1
  420. package/src/prover/smt/solver/relevancy.ts +1 -2
  421. package/src/prover/smt/solver/rewriter-tpl.ts +82 -14
  422. package/src/prover/smt/solver/rewriter.ts +505 -60
  423. package/src/prover/smt/solver/rlimit.ts +45 -5
  424. package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
  425. package/src/prover/smt/solver/sat/big.ts +177 -0
  426. package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
  427. package/src/prover/smt/solver/sat/clause.ts +203 -0
  428. package/src/prover/smt/solver/sat/cleaner.ts +94 -0
  429. package/src/prover/smt/solver/sat/config.ts +122 -0
  430. package/src/prover/smt/solver/sat/consequences.ts +203 -0
  431. package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
  432. package/src/prover/smt/solver/sat/goal2sat.ts +589 -0
  433. package/src/prover/smt/solver/sat/inc-sat-solver.ts +480 -0
  434. package/src/prover/smt/solver/sat/model-converter.ts +136 -0
  435. package/src/prover/smt/solver/sat/pb-constraint.ts +268 -0
  436. package/src/prover/smt/solver/sat/pb-solver.ts +1596 -0
  437. package/src/prover/smt/solver/sat/probing.ts +170 -0
  438. package/src/prover/smt/solver/sat/sat-tactic.ts +72 -0
  439. package/src/prover/smt/solver/sat/sat2goal.ts +190 -0
  440. package/src/prover/smt/solver/sat/scc.ts +142 -0
  441. package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
  442. package/src/prover/smt/solver/sat/solver.ts +2107 -0
  443. package/src/prover/smt/solver/sat/var-queue.ts +117 -0
  444. package/src/prover/smt/solver/sat/watch-list.ts +140 -0
  445. package/src/prover/smt/solver/search-tree.ts +284 -0
  446. package/src/prover/smt/solver/seq-axioms.ts +995 -0
  447. package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
  448. package/src/prover/smt/solver/seq-derive.ts +1298 -0
  449. package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
  450. package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
  451. package/src/prover/smt/solver/seq-factory.ts +89 -0
  452. package/src/prover/smt/solver/seq-monadic.ts +730 -0
  453. package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
  454. package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -0
  455. package/src/prover/smt/solver/seq-re-util.ts +758 -0
  456. package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
  457. package/src/prover/smt/solver/seq-regex-live.ts +200 -0
  458. package/src/prover/smt/solver/seq-rewriter.ts +2404 -0
  459. package/src/prover/smt/solver/seq-skolem.ts +294 -0
  460. package/src/prover/smt/solver/seq-subset.ts +165 -0
  461. package/src/prover/smt/solver/seq-view-witness.ts +353 -0
  462. package/src/prover/smt/solver/smt-consequences.ts +297 -0
  463. package/src/prover/smt/solver/smt-kernel.ts +124 -0
  464. package/src/prover/smt/solver/smt-logics.ts +66 -0
  465. package/src/prover/smt/solver/smt-setup.ts +589 -0
  466. package/src/prover/smt/solver/smt2-printer.ts +765 -0
  467. package/src/prover/smt/solver/smtlib-parser.ts +3535 -360
  468. package/src/prover/smt/solver/smtlib-script.ts +2136 -0
  469. package/src/prover/smt/solver/solve-eqs.ts +928 -0
  470. package/src/prover/smt/solver/solver.ts +128 -23
  471. package/src/prover/smt/solver/static-features.ts +314 -0
  472. package/src/prover/smt/solver/sticky-generations.ts +0 -1
  473. package/src/prover/smt/solver/tactic.ts +2176 -0
  474. package/src/prover/smt/solver/term-enumeration.ts +205 -0
  475. package/src/prover/smt/solver/theory-array.ts +1240 -0
  476. package/src/prover/smt/solver/theory-bv.ts +1210 -0
  477. package/src/prover/smt/solver/theory-char.ts +355 -0
  478. package/src/prover/smt/solver/theory-datatype.ts +598 -0
  479. package/src/prover/smt/solver/theory-finite-set.ts +30 -0
  480. package/src/prover/smt/solver/theory-fpa.ts +389 -0
  481. package/src/prover/smt/solver/theory-lra-axioms.ts +53 -2
  482. package/src/prover/smt/solver/theory-lra-bounds.ts +31 -6
  483. package/src/prover/smt/solver/theory-lra-final-check.ts +57 -70
  484. package/src/prover/smt/solver/theory-lra-internalize.ts +96 -27
  485. package/src/prover/smt/solver/theory-lra-model.ts +20 -35
  486. package/src/prover/smt/solver/theory-lra-propagate.ts +35 -28
  487. package/src/prover/smt/solver/theory-lra-state.ts +7 -23
  488. package/src/prover/smt/solver/theory-lra.ts +189 -2
  489. package/src/prover/smt/solver/theory-pb.ts +951 -0
  490. package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
  491. package/src/prover/smt/solver/theory-recfun.ts +307 -0
  492. package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
  493. package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
  494. package/src/prover/smt/solver/theory-seq-state.ts +852 -0
  495. package/src/prover/smt/solver/theory-seq.ts +961 -0
  496. package/src/prover/smt/solver/theory-without-terms.ts +24 -0
  497. package/src/prover/smt/solver/theory.ts +189 -0
  498. package/src/prover/smt/solver/tseitin-cnf.ts +495 -0
  499. package/src/prover/smt/solver/var-subst.ts +36 -14
  500. package/src/prover/smt/table.ts +3 -2
  501. package/src/prover/smt/types.ts +146 -0
  502. package/src/prover/tlapm/cache.ts +57 -26
  503. package/src/prover/tlapm/tlapm.ts +15 -9
  504. package/src/prover/tlapm-library.ts +3208 -0
  505. package/src/prover/verdict.ts +9 -0
  506. package/src/prover/zenon/check/check.ts +1 -2
  507. package/src/prover/zenon/check/records.ts +1 -1
  508. package/src/prover/zenon/check/relations.ts +2 -1
  509. package/src/prover/zenon/check/rewrites.ts +2 -15
  510. package/src/prover/zenon/check/sets.ts +40 -58
  511. package/src/prover/zenon/check/terms.ts +1 -2
  512. package/src/prover/zenon/decide.ts +10 -7
  513. package/src/prover/zenon/encode.ts +0 -2
  514. package/src/prover/zenon/eqrel.ts +2 -2
  515. package/src/prover/zenon/equality-rules.ts +24 -2
  516. package/src/prover/zenon/expr.ts +28 -2
  517. package/src/prover/zenon/index-table.ts +16 -23
  518. package/src/prover/zenon/isar-case.ts +1 -3
  519. package/src/prover/zenon/isar.ts +37 -39
  520. package/src/prover/zenon/llproof.ts +2 -13
  521. package/src/prover/zenon/mltoll.ts +12 -30
  522. package/src/prover/zenon/node.ts +20 -5
  523. package/src/prover/zenon/parse.ts +9 -8
  524. package/src/prover/zenon/phrase.ts +1 -3
  525. package/src/prover/zenon/proof.ts +0 -2
  526. package/src/prover/zenon/propositional-rules.ts +0 -2
  527. package/src/prover/zenon/rules.ts +2 -3
  528. package/src/prover/zenon/search.ts +11 -19
  529. package/src/prover/zenon/tla/functions.ts +2 -4
  530. package/src/prover/zenon/tla/llproof.ts +9 -13
  531. package/src/prover/zenon/tla/records.ts +1 -8
  532. package/src/prover/zenon/tla/rewrites.ts +0 -2
  533. package/src/prover/zenon/tla/sets.ts +22 -22
  534. package/src/prover/zenon/tla/terms.ts +0 -2
  535. package/src/prover/zenon/tla/tla.ts +7 -8
  536. package/src/resolve.ts +1327 -328
  537. package/src/runtime.ts +25 -2
  538. package/src/sany/builtins.ts +10 -10
  539. package/src/sany/generation.ts +384 -0
  540. package/src/sany/generator-def-entries.ts +297 -0
  541. package/src/sany/generator-definitions.ts +688 -0
  542. package/src/sany/generator-expressions.ts +1123 -0
  543. package/src/sany/generator-proofs.ts +668 -0
  544. package/src/sany/generator.ts +161 -2625
  545. package/src/sany/levels.ts +0 -2
  546. package/src/sany/lexer.ts +32 -23
  547. package/src/sany/linter.ts +0 -2
  548. package/src/sany/modules.ts +4 -2
  549. package/src/sany/nodes.ts +3 -4
  550. package/src/sany/report.ts +3 -6
  551. package/src/sany/selectors.ts +46 -44
  552. package/src/sany/xml.ts +25 -58
  553. package/src/search.ts +513 -165
  554. package/src/simulate.ts +340 -251
  555. package/src/spec-description.ts +48 -55
  556. package/src/standard-definitions.ts +5 -0
  557. package/src/standard-modules.ts +72 -54
  558. package/src/state-graph.ts +0 -2
  559. package/src/subexpressions.ts +564 -138
  560. package/src/substitution-levels.ts +5 -4
  561. package/src/successors.ts +56 -28
  562. package/src/symmetry.ts +4 -3
  563. package/src/tableau.ts +2 -2
  564. package/src/tlc/fingerprint.ts +81 -9
  565. package/src/tlc/jar-data.ts +10 -0
  566. package/src/tlc/messages.ts +23 -18
  567. package/src/tlc/order.ts +14 -3
  568. package/src/tlc/random.ts +6 -5
  569. package/src/tlc/replay.ts +152 -58
  570. package/src/tlc/summary.ts +29 -14
  571. package/src/tlc/tlc-operators.ts +12 -11
  572. package/src/tlc/tlcext-operators.ts +87 -26
  573. package/src/tlc/trace-spec.ts +27 -60
  574. package/src/trace-liveness.ts +529 -0
  575. package/src/typed-tier.ts +6556 -0
  576. package/src/typescript/actions.ts +2 -4
  577. package/src/typescript/collections.ts +34 -20
  578. package/src/typescript/compile.ts +1 -3
  579. package/src/typescript/formula.ts +5 -3
  580. package/src/typescript/model.ts +4 -5
  581. package/src/typescript/steps.ts +20 -18
  582. package/src/typescript/types.ts +2 -2
  583. package/src/values.ts +208 -227
  584. package/src/prover/isabelle/isar/statement.ts +0 -52
  585. package/src/prover/smt/solver/z3-license.txt +0 -10
  586. package/src/prover/tlaps-module.ts +0 -510
  587. package/src/prover/zenon/LICENSE +0 -32
package/src/parser.ts CHANGED
@@ -1,7 +1,6 @@
1
1
  import type {
2
2
  AssumeProve,
3
3
  Assumption,
4
- Bound,
5
4
  BoundPattern,
6
5
  CaseArm,
7
6
  Declaration,
@@ -22,9 +21,11 @@ import type {
22
21
  StepBody,
23
22
  UseOrHide,
24
23
  } from "./ast";
25
- import { createSanyError, formatRange, TlaSyntaxError } from "./errors";
24
+ import { TlaSyntaxError } from "./errors";
26
25
  import { getNumeralValue, readAtAsIdentifier, tokenize, type Token } from "./lexer";
26
+ import { getDefEntryErrors, type DefEntryError } from "./sany/generator-def-entries";
27
27
  import { getSanyParseError } from "./sany/parse-error";
28
+ import { createSourceFile } from "./sany/source";
28
29
 
29
30
  interface Precedence {
30
31
  low: number;
@@ -35,6 +36,24 @@ interface InfixOperator extends Precedence {
35
36
  isAssociative: boolean;
36
37
  }
37
38
 
39
+ interface TlapmOperand {
40
+ start: number;
41
+ end: number;
42
+ expression: Expression;
43
+ joinedBy?: string;
44
+ }
45
+
46
+ interface TlapmOperator extends Precedence {
47
+ start: number;
48
+ end: number;
49
+ fixity: "Prefix" | "Infix" | "Postfix";
50
+ isLeft: boolean;
51
+ joins?: string;
52
+ apply: (operands: TlapmOperand[]) => Expression;
53
+ }
54
+
55
+ type TlapmItem = TlapmOperand | TlapmOperator;
56
+
38
57
  const POSTFIX_PRECEDENCE = { low: 15, high: 15 };
39
58
  const FUNCTION_PRECEDENCE = { low: 16, high: 16 };
40
59
 
@@ -144,6 +163,49 @@ const INFIX_OPERATORS = new Map<string, InfixOperator>([
144
163
 
145
164
  const NEGATION_PRECEDENCE = 12;
146
165
 
166
+ // tlapm's Optable has SANY's infix precedences, groups % and \X to the left with the operators
167
+ // SANY takes as associative, and has these prefix precedences. A function application and a field
168
+ // bind above every operator.
169
+ const isTlapmLeft = (text: string, infix: InfixOperator) =>
170
+ infix.isAssociative || text === "%" || text === "\\X";
171
+
172
+ const TLAPM_PREFIX_OPERATORS = new Map<string, Precedence>([
173
+ ["~", { low: 4, high: 4 }],
174
+ ["[]", { low: 4, high: 15 }],
175
+ ["<>", { low: 4, high: 15 }],
176
+ ["ENABLED", { low: 4, high: 15 }],
177
+ ["UNCHANGED", { low: 4, high: 15 }],
178
+ ["SUBSET", { low: 8, high: 8 }],
179
+ ["UNION", { low: 8, high: 8 }],
180
+ ["DOMAIN", { low: 9, high: 9 }],
181
+ ["-", { low: 12, high: 12 }],
182
+ ["-.", { low: 12, high: 12 }],
183
+ ]);
184
+
185
+ const TLAPM_SELECTION_PRECEDENCE = { low: 17, high: 17 };
186
+
187
+ const TLAPM_ATOM_STARTS = new Set([
188
+ "(",
189
+ "[",
190
+ "{",
191
+ "<<",
192
+ "@",
193
+ "\\A",
194
+ "\\E",
195
+ "\\AA",
196
+ "\\EE",
197
+ "IF",
198
+ "CASE",
199
+ "LET",
200
+ "CHOOSE",
201
+ "LAMBDA",
202
+ "WF_",
203
+ "SF_",
204
+ ]);
205
+
206
+ // The brackets whose contents tlapm reads without committing, so a failure in them backtracks.
207
+ const TLAPM_OPEN_BRACKETS = new Set(["(", "{", "<<"]);
208
+
147
209
  const POSTFIX_OPERATORS = new Set(["^+", "^*", "^#"]);
148
210
 
149
211
  const DEFINABLE_POSTFIX_OPERATORS = new Set([...POSTFIX_OPERATORS, "'"]);
@@ -191,6 +253,7 @@ const OPERATOR_ARGUMENTS = new Set([
191
253
 
192
254
  const SELECTOR_SYMBOLS = new Set(["<<", ">>", ":", "@", "("]);
193
255
 
256
+ // Deviation from SANY: TLAplusParser#OpOrExpr's lookahead omits PROPOSITION, LEMMA and COROLLARY, so SANY parses an operator argument before them as an expression.
194
257
  const UNIT_KEYWORDS = new Set([
195
258
  "ASSUME",
196
259
  "ASSUMPTION",
@@ -315,13 +378,30 @@ const getSpan = (range: SourceRange): Span => ({
315
378
  stop: { line: range.end.line, column: range.end.column + 1 },
316
379
  });
317
380
 
318
- const createProofError = (message: string, span: Span, exception = "Proof.Parser") =>
381
+ interface ProofErrorEnds {
382
+ printed: string;
383
+ set: string;
384
+ }
385
+
386
+ const NO_NEWLINES: ProofErrorEnds = { printed: "", set: "" };
387
+
388
+ const PRINTED_NEWLINE: ProofErrorEnds = { printed: "\n", set: "" };
389
+
390
+ const NEWLINES: ProofErrorEnds = { printed: "\n", set: "\n" };
391
+
392
+ // p_parser.ml ends some of the messages it prints, and of those it sets, with a newline.
393
+ const createProofError = (
394
+ message: string,
395
+ span: Span,
396
+ ends: ProofErrorEnds,
397
+ exception = "Proof.Parser",
398
+ ) =>
319
399
  new TlaSyntaxError(message, undefined, {
320
- reason: message,
400
+ reason: `${message}${ends.set}`,
321
401
  line: span.start.line,
322
402
  column: span.start.column,
323
403
  isEnd: false,
324
- proof: { stop: span.stop, exception },
404
+ proof: { stop: span.stop, exception, printed: `${message}${ends.printed}` },
325
405
  });
326
406
 
327
407
  const FACT_KEYWORDS = new Set([
@@ -400,6 +480,26 @@ const getOperatorApplication = (
400
480
  }
401
481
  };
402
482
 
483
+ export const parenthesizedRanges = new WeakMap<Expression, SourceRange>();
484
+
485
+ export const defEntryErrors = new WeakMap<Expression, DefEntryError[]>();
486
+
487
+ export const getDefEntryBinder = (expression: Expression): Expression | undefined => {
488
+ if (parenthesizedRanges.has(expression)) return undefined;
489
+ const binder =
490
+ expression.kind === "UnboundedQuantifier"
491
+ ? { name: expression.names[0], range: expression.nameRanges?.[0] }
492
+ : expression.kind === "Choose" && expression.pattern.kind === "Name"
493
+ ? { name: expression.pattern.name, range: expression.pattern.ranges?.[0] }
494
+ : expression.kind === "SetFilter" && expression.bound.pattern.kind === "Name"
495
+ ? { name: expression.bound.pattern.name, range: expression.bound.pattern.ranges?.[0] }
496
+ : undefined;
497
+ const range = binder?.range;
498
+ return binder && range
499
+ ? { kind: "Identifier", name: binder.name, location: { ...range.start, range } }
500
+ : undefined;
501
+ };
502
+
403
503
  export const extractModule = (source: string, name: string) => {
404
504
  const header = new RegExp(`^-{4,}\\s*MODULE\\s+${name}\\s*-{3,}$`);
405
505
  const lines = source.replace(/\r?\n$/, "").split(/\r?\n/);
@@ -423,9 +523,12 @@ const parse = (
423
523
  let lastOperator: Precedence | undefined;
424
524
  let precedingOperator: Precedence | undefined;
425
525
  const recursiveScopes: Set<string>[] = [];
426
- const factNames = new Set<string>();
427
- const proofScopes: Set<string>[] = [];
428
526
  const openModules: Module[] = [];
527
+ // Pco's backtracking: a failure not past a commit rewinds to its attempt's frame.
528
+ let attemptFrame: number | undefined;
529
+ let attemptCount = 0;
530
+ const restorePoints: number[] = [];
531
+ const backtracks = new WeakMap<TlaSyntaxError, number>();
429
532
 
430
533
  const isRecursiveName = (name: string) => recursiveScopes[recursiveScopes.length - 1].has(name);
431
534
 
@@ -473,15 +576,6 @@ const parse = (
473
576
  const describeToken = (token: Token) =>
474
577
  token.kind === "End" ? "end of input" : JSON.stringify(token.text);
475
578
 
476
- let unitStart = 0;
477
-
478
- const getDefinitionEnd = (fallback: Point) => {
479
- const equals = tokens
480
- .slice(unitStart, cursor)
481
- .find((token) => token.text === "==" && token.kind !== "String");
482
- return equals ? { line: equals.line, column: equals.endColumn + 1 } : fallback;
483
- };
484
-
485
579
  const isTlapmKeyword = (token: Token) =>
486
580
  isTlapm && (token.kind === "Keyword" || BUILTIN_CONSTANTS.has(token.text));
487
581
 
@@ -496,6 +590,7 @@ const parse = (
496
590
  };
497
591
 
498
592
  const getTlapmName = (token: Token) => {
593
+ if (token.kind === "End") return "EOF";
499
594
  if (/^-{4,}$/.test(token.text)) return "----";
500
595
  if (/^={4,}$/.test(token.text)) return "====";
501
596
  if (TLAPM_PUNCTUATION.has(token.text) || token.kind === "Number" || token.kind === "Decimal")
@@ -509,36 +604,76 @@ const parse = (
509
604
  const createError = (message: string, token: Point = peekRaw(), unexpected?: Token) => {
510
605
  const end = tokens[tokens.length - 1];
511
606
  const isEnd = token.line === end.line && token.column === end.column;
512
- return new TlaSyntaxError(
607
+ const error = new TlaSyntaxError(
513
608
  `${message} at line ${token.line}, column ${token.column}`,
514
609
  undefined,
515
610
  getFailure(message, token, isEnd, unexpected),
516
611
  );
612
+ if (attemptFrame !== undefined) backtracks.set(error, attemptFrame);
613
+ return error;
517
614
  };
518
615
 
616
+ // tlapm reports a failure after the last token it read before the outermost attempt around it.
519
617
  const getFailure = (
520
618
  message: string,
521
619
  token: Point,
522
620
  isEnd: boolean,
523
621
  unexpected: Token | undefined,
524
622
  ) => {
525
- if (isTlapm && isEnd) {
526
- const end = tokens[tokens.length - 1];
527
- return { reason: "Unexpected EOF", ...getDefinitionEnd(getPreviousEnd(end)), isEnd };
528
- }
529
- if (isTlapm && unexpected) {
530
- return {
531
- reason: `Unexpected ${getTlapmName(unexpected)}`,
532
- ...getPreviousEnd(unexpected),
533
- isEnd,
534
- };
535
- }
536
- return { reason: message, line: token.line, column: token.column, isEnd };
623
+ if (!isTlapm) return { reason: message, line: token.line, column: token.column, isEnd };
624
+ const restored = tokens[restorePoints[0] - 1];
625
+ const reason = unexpected ? `Unexpected ${getTlapmName(unexpected)}` : message;
626
+ if (restored) return { reason, line: restored.line, column: restored.endColumn + 1, isEnd };
627
+ const position = unexpected ? getPreviousEnd(unexpected) : token;
628
+ return { reason, line: position.line, column: position.column, isEnd };
537
629
  };
538
630
 
539
631
  const createUnexpected = (message: string, token: Token = peekRaw()) =>
540
632
  createError(message, token, token);
541
633
 
634
+ // Pco.attempt: a failure that backtracks to it leaves the input as it was, and gives undefined.
635
+ const attempt = <Result>(parse: () => Result): Result | undefined => {
636
+ const saved = {
637
+ cursor,
638
+ frame: attemptFrame,
639
+ restorePoints: restorePoints.length,
640
+ offsideColumns: offsideColumns.length,
641
+ recursiveScopes: recursiveScopes.length,
642
+ };
643
+ const frame = ++attemptCount;
644
+ attemptFrame = frame;
645
+ try {
646
+ const result = parse();
647
+ attemptFrame = saved.frame;
648
+ return result;
649
+ } catch (error) {
650
+ if (!(error instanceof TlaSyntaxError) || backtracks.get(error) !== frame) throw error;
651
+ cursor = saved.cursor;
652
+ attemptFrame = saved.frame;
653
+ restorePoints.length = saved.restorePoints;
654
+ offsideColumns.length = saved.offsideColumns;
655
+ recursiveScopes.length = saved.recursiveScopes;
656
+ return undefined;
657
+ }
658
+ };
659
+
660
+ // Pco.commit: a failure in parse no longer backtracks.
661
+ const commit = <Result>(parse: () => Result) => {
662
+ const frame = attemptFrame;
663
+ attemptFrame = undefined;
664
+ const result = parse();
665
+ attemptFrame = frame;
666
+ return result;
667
+ };
668
+
669
+ const withRestorePoint = <Result>(parse: () => Result) => {
670
+ restorePoints.push(cursor);
671
+ const result = parse();
672
+ restorePoints.pop();
673
+ return result;
674
+ };
675
+
676
+ // Deviation from SANY: TLAplusParser#belchDEF reads a field named THEOREM, AXIOM, DOMAIN or a like keyword as that keyword, so SANY rejects the definition after it.
542
677
  const isFieldName = (token: Token) =>
543
678
  (token.kind === "Identifier" ||
544
679
  token.kind === "Keyword" ||
@@ -552,7 +687,7 @@ const parse = (
552
687
 
553
688
  const advance = () => {
554
689
  const token = peek();
555
- if (token.kind === "End") throw createError("Unexpected end of expression");
690
+ if (token.kind === "End") throw createUnexpected("Unexpected end of expression");
556
691
  cursor++;
557
692
  return token;
558
693
  };
@@ -622,13 +757,13 @@ const parse = (
622
757
  return items;
623
758
  };
624
759
 
625
- const isBoundAhead = () => {
626
- if (isAt("<<")) {
627
- let offset = 1;
760
+ const isBoundAhead = (start = 0) => {
761
+ if (isAt("<<", start)) {
762
+ let offset = start + 1;
628
763
  while (peek(offset).kind === "Identifier" || isAt(",", offset)) offset++;
629
764
  return isAt(">>", offset) && isAt("\\in", offset + 1);
630
765
  }
631
- let offset = 0;
766
+ let offset = start;
632
767
  while (peek(offset).kind === "Identifier") {
633
768
  if (isAt("\\in", offset + 1)) return true;
634
769
  if (!isAt(",", offset + 1)) return false;
@@ -655,13 +790,21 @@ const parse = (
655
790
  return { kind: "Tuple", names: names.names, ranges: names.ranges };
656
791
  };
657
792
 
658
- const parseBounds = () =>
659
- parseSeparated(() => {
793
+ // tlapm's func_boundeds reads another bound only where names and \in follow the comma.
794
+ const parseBounds = () => {
795
+ const parseBound = () => {
660
796
  const patterns = parseSeparated(parsePattern);
661
797
  expect("\\in");
662
- const set = parseExpression();
798
+ const set = commit(parseExpression);
663
799
  return patterns.map((pattern) => ({ pattern, set }));
664
- }).flat();
800
+ };
801
+ const bounds = [parseBound()];
802
+ while (isAt(",") && (!isTlapm || isBoundAhead(1))) {
803
+ advance();
804
+ bounds.push(parseBound());
805
+ }
806
+ return bounds.flat();
807
+ };
665
808
 
666
809
  const parseSubscript = (): { subscript: Expression; lastArgs: Expression[] } => {
667
810
  const token = peek();
@@ -823,7 +966,11 @@ const parse = (
823
966
  start,
824
967
  );
825
968
  }
826
- return parseExpression();
969
+ if (!isTlapm) return parseExpression();
970
+ // tlapm's oparg reads an operator where an expression doesn't start, and fails otherwise.
971
+ const argument = attempt(parseExpression);
972
+ if (argument) return argument;
973
+ throw createUnexpected(`Unexpected ${describeToken(peek())}`);
827
974
  };
828
975
 
829
976
  let lastArgumentsRange: SourceRange | undefined;
@@ -842,14 +989,19 @@ const parse = (
842
989
  const bullet = advance();
843
990
  offsideColumns.push(bullet.column);
844
991
  const operands = [parseExpression()];
845
- while (
846
- isBullet(peekRaw()) &&
847
- peekRaw().text === bullet.text &&
848
- peekRaw().column === bullet.column
849
- ) {
850
- cursor++;
851
- operands.push(parseExpression());
852
- }
992
+ const parseItems = () => {
993
+ while (
994
+ isBullet(peekRaw()) &&
995
+ peekRaw().text === bullet.text &&
996
+ peekRaw().column === bullet.column
997
+ ) {
998
+ cursor++;
999
+ operands.push(parseExpression());
1000
+ }
1001
+ };
1002
+ // bulleted_list: a first item that fails leaves expr_or_op's other readings to fail after it.
1003
+ if (isTlapm) commit(parseItems);
1004
+ else parseItems();
853
1005
  offsideColumns.pop();
854
1006
  return {
855
1007
  kind: bullet.text === "/\\" ? "And" : "Or",
@@ -900,22 +1052,45 @@ const parse = (
900
1052
  }
901
1053
  if (accept("EXCEPT")) {
902
1054
  const updates = parseSeparated(() => {
1055
+ const heirStarts = [cursor];
903
1056
  expect("!");
904
- const path: ExceptPathStep[] = [];
1057
+ const components: (string | Expression[])[] = [];
905
1058
  while (isAt(".") || isAt("[")) {
1059
+ heirStarts.push(cursor);
906
1060
  if (accept(".")) {
907
1061
  if (!isFieldName(peek()))
908
1062
  throw createUnexpected(`Expected a field name but found ${describeToken(peek())}`);
909
1063
  if (!isTlapm && isAt("@")) throw createUnexpected("@ used in !.@");
910
- path.push({ kind: "Field", name: advance().text });
1064
+ components.push(advance().text);
911
1065
  continue;
912
1066
  }
913
1067
  expect("[");
914
- path.push({ kind: "Index", args: parseSeparated(() => parseExpression()) });
1068
+ components.push(parseSeparated(() => parseExpression()));
915
1069
  expect("]");
916
1070
  }
1071
+ heirStarts.push(cursor, cursor + 1);
917
1072
  expect("=");
918
- return { path, value: parseExpression() };
1073
+ const value = parseExpression();
1074
+ heirStarts.push(cursor);
1075
+ const getHeirRange = (index: number) =>
1076
+ getRange(heirStarts[index], heirStarts[index + 1] - 1);
1077
+ return {
1078
+ path: components.map((component, index): ExceptPathStep =>
1079
+ typeof component === "string"
1080
+ ? { kind: "Field", name: component }
1081
+ : {
1082
+ kind: "Index",
1083
+ args: component,
1084
+ // SANY's Generator locates the $Tuple of component i at heir 2i + 1 of its ExceptSpec, not i + 1.
1085
+ // Deviation from SANY: past the last heir, that throws ArrayIndexOutOfBoundsException; tla-ts locates it at the component.
1086
+ tupleRange: getHeirRange(
1087
+ 2 * index + 1 < heirStarts.length - 1 ? 2 * index + 1 : index + 1,
1088
+ ),
1089
+ },
1090
+ ),
1091
+ value,
1092
+ range: getRange(heirStarts[0]),
1093
+ };
919
1094
  });
920
1095
  expect("]");
921
1096
  return { kind: "Except", function: expression, updates, location };
@@ -940,7 +1115,7 @@ const parse = (
940
1115
  const element = withRange(parsePrefix(), start);
941
1116
  const location = getLocation(advance());
942
1117
  return withRange(
943
- { kind: "Apply", operator: "\\in", args: [element, parseExpression()], location },
1118
+ { kind: "Apply", operator: "\\in", args: [element, commit(parseExpression)], location },
944
1119
  start,
945
1120
  );
946
1121
  };
@@ -953,9 +1128,9 @@ const parse = (
953
1128
  const checkpoint = cursor;
954
1129
  const pattern = parsePattern();
955
1130
  expect("\\in");
956
- const set = parseExpression();
1131
+ const set = commit(parseExpression);
957
1132
  if (accept(":")) {
958
- const predicate = parseExpression();
1133
+ const predicate = commit(parseExpression);
959
1134
  expect("}");
960
1135
  return { kind: "SetFilter", bound: { pattern, set }, predicate, location };
961
1136
  }
@@ -985,7 +1160,7 @@ const parse = (
985
1160
  return {
986
1161
  kind: "AngleAction",
987
1162
  action: elements[0],
988
- subscript: parseSubscript().subscript,
1163
+ subscript: commit(parseSubscript).subscript,
989
1164
  location,
990
1165
  };
991
1166
  }
@@ -1070,6 +1245,55 @@ const parse = (
1070
1245
  return { kind: "Name", name: token.text, args: isAt("(") ? parseArguments() : [] };
1071
1246
  };
1072
1247
 
1248
+ const parseSelections = (
1249
+ name: string,
1250
+ args: Expression[],
1251
+ argumentsRange: SourceRange | undefined,
1252
+ start: number,
1253
+ location: SourceLocation,
1254
+ ): Expression => {
1255
+ const selectors: Selector[] = [{ kind: "Name", name, args }];
1256
+ const selectorRanges = [getRange(start, start)];
1257
+ const argumentRanges = [argumentsRange];
1258
+ while (isSelectorAhead()) {
1259
+ advance();
1260
+ const selectorStart = cursor;
1261
+ lastArgumentsRange = undefined;
1262
+ const selector = parseSelector();
1263
+ selectorRanges.push(
1264
+ selector.kind === "Bound"
1265
+ ? getRange(selectorStart)
1266
+ : getRange(selectorStart, selectorStart),
1267
+ );
1268
+ selectors.push(selector);
1269
+ argumentRanges.push(lastArgumentsRange);
1270
+ }
1271
+ const names = selectors.flatMap((selector) =>
1272
+ selector.kind === "Name" ? [selector.name] : [],
1273
+ );
1274
+ const operator = names.join("!");
1275
+ const qualifiedArgs = selectors.flatMap((selector) =>
1276
+ "args" in selector ? selector.args : [],
1277
+ );
1278
+ const argumentCounts = selectors.map((selector) =>
1279
+ "args" in selector ? selector.args.length : 0,
1280
+ );
1281
+ return names.length < selectors.length
1282
+ ? { kind: "Subexpression", selectors, selectorRanges, argumentRanges, location }
1283
+ : qualifiedArgs.length === 0
1284
+ ? { kind: "Identifier", name: operator, selectorRanges, location }
1285
+ : {
1286
+ kind: "Apply",
1287
+ operator,
1288
+ args: qualifiedArgs,
1289
+ ...(argumentCounts.slice(0, -1).some((count) => count > 0) && { argumentCounts }),
1290
+ argumentsRange: argumentRanges.at(-1) ?? getRange(start),
1291
+ selectorRanges,
1292
+ argumentRanges,
1293
+ location,
1294
+ };
1295
+ };
1296
+
1073
1297
  const parsePrimary = (preceding?: Precedence): Expression => {
1074
1298
  const start = cursor;
1075
1299
  const token = advance();
@@ -1079,10 +1303,8 @@ const parse = (
1079
1303
  expect(":");
1080
1304
  return { kind: "Lambda", params, body: parseExpression(), location };
1081
1305
  }
1082
- if (token.kind === "Number") {
1083
- if (isTlapm && /^\\[BOH]/.test(token.text)) throw createError("incomplete expression", token);
1306
+ if (token.kind === "Number")
1084
1307
  return { kind: "Number", value: getNumeralValue(token.text), text: token.text, location };
1085
- }
1086
1308
  if (token.kind === "Decimal") return { kind: "Decimal", text: token.text, location };
1087
1309
  if (token.kind === "String") return { kind: "String", value: token.text, location };
1088
1310
  const isStep = token.kind === "Step" && isStepReference(token);
@@ -1123,61 +1345,51 @@ const parse = (
1123
1345
  if (name === "@" && !hasArguments && !isSelectorAhead())
1124
1346
  return { kind: "ExceptAt", location };
1125
1347
  const args = hasArguments ? parseArguments() : [];
1126
- const argumentRanges = [hasArguments ? lastArgumentsRange : undefined];
1127
1348
  if (!isSelectorAhead()) {
1128
1349
  return hasArguments
1129
1350
  ? { kind: "Apply", operator: name, args, argumentsRange: lastArgumentsRange, location }
1130
1351
  : { kind: "Identifier", name, location };
1131
1352
  }
1132
- const selectors: Selector[] = [{ kind: "Name", name, args }];
1133
- const selectorRanges = [getRange(start, start)];
1134
- while (isSelectorAhead()) {
1135
- advance();
1136
- selectorRanges.push(getRange(cursor, cursor));
1137
- lastArgumentsRange = undefined;
1138
- selectors.push(parseSelector());
1139
- argumentRanges.push(lastArgumentsRange);
1140
- }
1141
- const names = selectors.flatMap((selector) =>
1142
- selector.kind === "Name" ? [selector.name] : [],
1143
- );
1144
- const operator = names.join("!");
1145
- const qualifiedArgs = selectors.flatMap((selector) =>
1146
- "args" in selector ? selector.args : [],
1147
- );
1148
- const argumentCounts = selectors.map((selector) =>
1149
- "args" in selector ? selector.args.length : 0,
1353
+ return parseSelections(
1354
+ name,
1355
+ args,
1356
+ hasArguments ? lastArgumentsRange : undefined,
1357
+ start,
1358
+ location,
1150
1359
  );
1151
- const argumentsRange = argumentRanges.at(-1) ?? getRange(start);
1152
- return names.length < selectors.length
1153
- ? { kind: "Subexpression", selectors, selectorRanges, argumentRanges, location }
1154
- : qualifiedArgs.length === 0
1155
- ? { kind: "Identifier", name: operator, selectorRanges, location }
1156
- : {
1157
- kind: "Apply",
1158
- operator,
1159
- args: qualifiedArgs,
1160
- ...(argumentCounts.slice(0, -1).some((count) => count > 0) && { argumentCounts }),
1161
- argumentsRange,
1162
- selectorRanges,
1163
- argumentRanges,
1164
- location,
1165
- };
1166
1360
  }
1167
- if (token.kind === "Operator" && isOperatorName(token.text) && isAt("(")) {
1361
+ const isOperatorNamed =
1362
+ token.kind === "Operator" && (isOperatorName(token.text) || (token.text === "'" && !isTlapm));
1363
+ if (isOperatorNamed && isAt("(")) {
1168
1364
  const args = parseArguments();
1365
+ if (!isTlapm && isSelectorAhead()) {
1366
+ return parseSelections(token.text, args, lastArgumentsRange, start, location);
1367
+ }
1169
1368
  // Deviation from TLC: SANY's built-in \X has no definition for TLC to evaluate, a TLC bug.
1170
- return mode === "tlc" && token.text === "\\X" && args.length === 2
1171
- ? { kind: "Product", factors: args, location }
1172
- : { kind: "Apply", operator: token.text, spelling: token.spelling, args, location };
1369
+ if (mode === "tlc" && token.text === "\\X" && args.length === 2) {
1370
+ return { kind: "Product", factors: args, location };
1371
+ }
1372
+ return token.text === "'" && args.length === 1
1373
+ ? { kind: "Prime", expression: args[0], location }
1374
+ : {
1375
+ kind: "Apply",
1376
+ operator: token.text,
1377
+ spelling: token.spelling,
1378
+ args,
1379
+ argumentsRange: lastArgumentsRange,
1380
+ location,
1381
+ };
1173
1382
  }
1174
- if (token.kind === "Operator" && isOperatorName(token.text) && !isTlapm) {
1175
- return { kind: "Identifier", name: token.text, spelling: token.spelling, location };
1383
+ if (isOperatorNamed && !isTlapm) {
1384
+ return isSelectorAhead()
1385
+ ? parseSelections(token.text, [], undefined, start, location)
1386
+ : { kind: "Identifier", name: token.text, spelling: token.spelling, location };
1176
1387
  }
1177
1388
  switch (token.text) {
1178
1389
  case "(": {
1179
1390
  const expression = withBracketLayout(() => parseExpression());
1180
1391
  expect(")");
1392
+ parenthesizedRanges.set(expression, getRange(start));
1181
1393
  return expression;
1182
1394
  }
1183
1395
  case "[":
@@ -1205,12 +1417,13 @@ const parse = (
1205
1417
  case "LET": {
1206
1418
  const definitions: Definition[] = [];
1207
1419
  const instances: Instance[] = [];
1420
+ const recursive: Declaration[] = [];
1208
1421
  recursiveScopes.push(new Set());
1209
1422
  while (!accept("IN")) {
1210
- if (isTlapm && isAt("RECURSIVE"))
1211
- throw createError("Unexpected keyword RECURSIVE", getDefinitionEnd(peekRaw()));
1423
+ if (isTlapm && isAt("RECURSIVE")) throw createUnexpected("Unexpected keyword RECURSIVE");
1212
1424
  if (accept("RECURSIVE")) {
1213
- declareRecursive();
1425
+ recursive.push(...declareRecursive());
1426
+ openModules[openModules.length - 1].hasRecursiveLet = true;
1214
1427
  continue;
1215
1428
  }
1216
1429
  const unit = parseDefinition(!isTlapm && accept("LOCAL"));
@@ -1218,10 +1431,14 @@ const parse = (
1218
1431
  else definitions.push(unit);
1219
1432
  }
1220
1433
  recursiveScopes.pop();
1221
- const body = parseExpression();
1222
- return instances.length === 0
1223
- ? { kind: "Let", definitions, body, location }
1224
- : { kind: "Let", definitions, instances, body, location };
1434
+ return {
1435
+ kind: "Let",
1436
+ definitions,
1437
+ ...(instances.length > 0 && { instances }),
1438
+ ...(recursive.length > 0 && { recursive }),
1439
+ body: parseExpression(),
1440
+ location,
1441
+ };
1225
1442
  }
1226
1443
  case "CHOOSE": {
1227
1444
  const pattern = parsePattern();
@@ -1254,14 +1471,12 @@ const parse = (
1254
1471
 
1255
1472
  const parsePrefixOperand = (operator: Token, low: number, high: number) => {
1256
1473
  lastOperator = precedingOperator = { low, high };
1257
- const operand = parseExpression(
1258
- isTlapm ? Math.min(high + 1, POSTFIX_PRECEDENCE.low) : high + 1,
1259
- );
1474
+ const operand = parseExpression(high + 1);
1260
1475
  const next = peek();
1261
1476
  const nextHigh = DEFINABLE_POSTFIX_OPERATORS.has(next.text)
1262
1477
  ? POSTFIX_PRECEDENCE.high
1263
1478
  : INFIX_OPERATORS.get(next.text)?.high;
1264
- if (!isTlapm && next.kind === "Operator" && nextHigh !== undefined && nextHigh >= low) {
1479
+ if (next.kind === "Operator" && nextHigh !== undefined && nextHigh >= low) {
1265
1480
  throw createError(`Precedence conflict between ${operator.text} and ${next.text}`, next);
1266
1481
  }
1267
1482
  return operand;
@@ -1275,26 +1490,6 @@ const parse = (
1275
1490
  if (token.kind === "Operator" && isBullet(token)) {
1276
1491
  return parseJunctionList();
1277
1492
  }
1278
- if (isTlapm && INFIX_OPERATORS.has(token.text) && isAt("(", 1)) {
1279
- const start = cursor;
1280
- const nonfix = withBracketLayout(() => {
1281
- advance();
1282
- advance();
1283
- const left = parseExpression();
1284
- if (!accept(",")) return undefined;
1285
- const right = parseExpression();
1286
- expect(")");
1287
- const apply: Expression = {
1288
- kind: "Apply",
1289
- operator: token.text,
1290
- args: [left, right],
1291
- location,
1292
- };
1293
- return withRange(apply, start);
1294
- });
1295
- if (nonfix !== undefined) return nonfix;
1296
- cursor = start;
1297
- }
1298
1493
  if (token.kind === "Operator" || token.kind === "Keyword") {
1299
1494
  switch (token.text) {
1300
1495
  case "~":
@@ -1306,8 +1501,6 @@ const parse = (
1306
1501
  location,
1307
1502
  };
1308
1503
  case "-":
1309
- case "-.":
1310
- if (token.text === "-." && !isTlapm) break;
1311
1504
  advance();
1312
1505
  return {
1313
1506
  kind: "Apply",
@@ -1316,17 +1509,11 @@ const parse = (
1316
1509
  location,
1317
1510
  };
1318
1511
  case "[]":
1319
- advance();
1320
- return { kind: "Always", expression: parsePrefixOperand(token, 4, 15), location };
1321
1512
  case "<>":
1322
- advance();
1323
- return { kind: "Eventually", expression: parsePrefixOperand(token, 4, 15), location };
1324
1513
  case "ENABLED":
1325
- advance();
1326
- return { kind: "Enabled", expression: parsePrefixOperand(token, 4, 15), location };
1327
1514
  case "UNCHANGED":
1328
1515
  advance();
1329
- return { kind: "Unchanged", expression: parsePrefixOperand(token, 4, 15), location };
1516
+ return getOperatorApplication(token.text, parsePrefixOperand(token, 4, 15), location);
1330
1517
  case "SUBSET":
1331
1518
  case "UNION":
1332
1519
  case "DOMAIN":
@@ -1334,7 +1521,7 @@ const parse = (
1334
1521
  return {
1335
1522
  kind: "Apply",
1336
1523
  operator: token.text,
1337
- args: [isTlapm ? parseExpression(9) : parsePrefixOperand(token, 10, 13)],
1524
+ args: [parsePrefixOperand(token, 10, 13)],
1338
1525
  location,
1339
1526
  };
1340
1527
  }
@@ -1342,7 +1529,57 @@ const parse = (
1342
1529
  return parsePrimary(preceding);
1343
1530
  };
1344
1531
 
1345
- const parseExpression = (minimumPrecedence = 0): Expression => {
1532
+ const getInfixApplication = (
1533
+ token: Token,
1534
+ left: Expression,
1535
+ right: Expression,
1536
+ isChained: boolean,
1537
+ prefixEnd: Point,
1538
+ ): Expression => {
1539
+ const location = getLocation(token);
1540
+ if (token.text === "/\\" || token.text === "\\/") {
1541
+ const kind = token.text === "/\\" ? "And" : "Or";
1542
+ return left.kind === kind && isChained
1543
+ ? {
1544
+ ...left,
1545
+ operands: [...left.operands, right],
1546
+ prefixEnds: [...(left.prefixEnds ?? []), prefixEnd],
1547
+ }
1548
+ : { kind, operands: [left, right], prefixEnds: [prefixEnd], location };
1549
+ }
1550
+ if (token.text === "\\X") {
1551
+ return left.kind === "Product" && isChained
1552
+ ? { ...left, factors: [...left.factors, right] }
1553
+ : { kind: "Product", factors: [left, right], location };
1554
+ }
1555
+ return {
1556
+ kind: "Apply",
1557
+ operator: token.text,
1558
+ spelling: token.spelling,
1559
+ args: [left, right],
1560
+ location,
1561
+ };
1562
+ };
1563
+
1564
+ const getPostfixApplication = (token: Token, operand: Expression): Expression =>
1565
+ token.text === "'"
1566
+ ? { kind: "Prime", expression: operand, location: getLocation(token) }
1567
+ : {
1568
+ kind: "Apply",
1569
+ operator: token.text,
1570
+ spelling: token.spelling,
1571
+ args: [operand],
1572
+ location: getLocation(token),
1573
+ };
1574
+
1575
+ const parseFunctionArguments = () => {
1576
+ advance();
1577
+ const args = withBracketLayout(() => parseSeparated(() => parseExpression()));
1578
+ withBracketLayout(() => expect("]"));
1579
+ return args;
1580
+ };
1581
+
1582
+ const parseSanyExpression = (minimumPrecedence: number): Expression => {
1346
1583
  const start = cursor;
1347
1584
  const prefix = parsePrefix();
1348
1585
  let left = prefix.location.range ? prefix : withRange(prefix, start);
@@ -1351,31 +1588,14 @@ const parse = (
1351
1588
  const token = peek();
1352
1589
  if (token.kind !== "Operator") break;
1353
1590
  const location = getLocation(token);
1354
- if (token.text === "'" && minimumPrecedence <= 15) {
1355
- advance();
1356
- lastOperator = POSTFIX_PRECEDENCE;
1357
- left = withRange({ kind: "Prime", expression: left, location }, start);
1358
- continue;
1359
- }
1360
- if (POSTFIX_OPERATORS.has(token.text) && minimumPrecedence <= 15) {
1591
+ if (DEFINABLE_POSTFIX_OPERATORS.has(token.text) && minimumPrecedence <= 15) {
1361
1592
  advance();
1362
1593
  lastOperator = POSTFIX_PRECEDENCE;
1363
- left = withRange(
1364
- {
1365
- kind: "Apply",
1366
- operator: token.text,
1367
- spelling: token.spelling,
1368
- args: [left],
1369
- location,
1370
- },
1371
- start,
1372
- );
1594
+ left = withRange(getPostfixApplication(token, left), start);
1373
1595
  continue;
1374
1596
  }
1375
1597
  if (token.text === "[") {
1376
- advance();
1377
- const args = withBracketLayout(() => parseSeparated(() => parseExpression()));
1378
- withBracketLayout(() => expect("]"));
1598
+ const args = parseFunctionArguments();
1379
1599
  lastOperator = FUNCTION_PRECEDENCE;
1380
1600
  left = withRange({ kind: "FunctionApplication", function: left, args, location }, start);
1381
1601
  continue;
@@ -1399,42 +1619,260 @@ const parse = (
1399
1619
  }
1400
1620
  }
1401
1621
  advance();
1402
- if (!isTlapm && infix.low > NEGATION_PRECEDENCE && isAt("-")) {
1622
+ if (infix.low > NEGATION_PRECEDENCE && isAt("-")) {
1403
1623
  throw createError(`Precedence conflict between ${token.text} and -`, peek());
1404
1624
  }
1405
1625
  lastOperator = precedingOperator = infix;
1406
1626
  const right = parseExpression(infix.high + 1);
1407
- if (token.text === "/\\" || token.text === "\\/") {
1408
- const kind = token.text === "/\\" ? "And" : "Or";
1409
- const prefixEnds = [getRange(start).end];
1410
- left =
1411
- left.kind === kind && previous?.text === token.text
1412
- ? {
1413
- ...left,
1414
- operands: [...left.operands, right],
1415
- prefixEnds: [...(left.prefixEnds ?? []), ...prefixEnds],
1416
- }
1417
- : { kind, operands: [left, right], prefixEnds, location };
1418
- } else if (token.text === "\\X") {
1419
- left =
1420
- left.kind === "Product" && previous?.text === "\\X"
1421
- ? { ...left, factors: [...left.factors, right] }
1422
- : { kind: "Product", factors: [left, right], location };
1423
- } else {
1424
- left = {
1425
- kind: "Apply",
1426
- operator: token.text,
1427
- spelling: token.spelling,
1428
- args: [left, right],
1627
+ const isChained = previous?.text === token.text;
1628
+ left = withRange(
1629
+ getInfixApplication(token, left, right, isChained, getRange(start).end),
1630
+ start,
1631
+ );
1632
+ previous = { ...infix, text: token.text };
1633
+ }
1634
+ return left;
1635
+ };
1636
+
1637
+ const isTlapmAtomStart = (token: Token) =>
1638
+ token.kind === "Number" ||
1639
+ token.kind === "Decimal" ||
1640
+ token.kind === "String" ||
1641
+ token.kind === "Identifier" ||
1642
+ (token.kind === "Step" && isStepReference(token) && /^<\d/.test(token.text)) ||
1643
+ ((token.kind === "Operator" || token.kind === "Keyword") && TLAPM_ATOM_STARTS.has(token.text));
1644
+
1645
+ const getTlapmOperand = (expression: Expression, start: number): TlapmOperand => ({
1646
+ start,
1647
+ end: cursor - 1,
1648
+ expression: expression.location.range ? expression : withRange(expression, start),
1649
+ });
1650
+
1651
+ const getTlapmOperator = (
1652
+ start: number,
1653
+ fixity: TlapmOperator["fixity"],
1654
+ precedence: Precedence,
1655
+ apply: TlapmOperator["apply"],
1656
+ ): TlapmOperator => ({
1657
+ ...precedence,
1658
+ start,
1659
+ end: cursor - 1,
1660
+ fixity,
1661
+ isLeft: false,
1662
+ apply,
1663
+ });
1664
+
1665
+ // expr_or_op's non_test: a postfix operator before an expression in parentheses is an atom.
1666
+ const parseTlapmNonfixPostfix = (token: Token) =>
1667
+ token.kind === "Operator" && DEFINABLE_POSTFIX_OPERATORS.has(token.text) && isAt("(", 1)
1668
+ ? attempt(() =>
1669
+ withBracketLayout(() => {
1670
+ advance();
1671
+ advance();
1672
+ const operand = parseExpression();
1673
+ const end = cursor - 1;
1674
+ expect(")");
1675
+ return { end, expression: getPostfixApplication(token, operand) };
1676
+ }),
1677
+ )
1678
+ : undefined;
1679
+
1680
+ // A comma directly inside the parentheses after the operator, without which non_test's
1681
+ // attempt at `(e, f)` fails. A selector's << or >> isn't a bracket.
1682
+ const hasNonfixComma = () => {
1683
+ let depth = 0;
1684
+ for (let index = cursor + 1; index < tokens.length; index++) {
1685
+ const token = tokens[index];
1686
+ if (token.kind !== "Operator") continue;
1687
+ if (depth === 1 && token.text === ",") return true;
1688
+ if (tokens[index - 1].text === "!") continue;
1689
+ if (OPENING_BRACKETS.has(token.text)) depth++;
1690
+ if (CLOSING_BRACKETS.has(token.text) && --depth === 0) return false;
1691
+ }
1692
+ return false;
1693
+ };
1694
+
1695
+ // expr_or_op's non_test: an infix operator before two expressions in parentheses is an atom.
1696
+ const parseTlapmNonfixInfix = (token: Token) =>
1697
+ isAt("(", 1) && hasNonfixComma()
1698
+ ? attempt(() =>
1699
+ withBracketLayout((): Expression => {
1700
+ advance();
1701
+ advance();
1702
+ const left = parseExpression();
1703
+ expect(",");
1704
+ const right = parseExpression();
1705
+ expect(")");
1706
+ return {
1707
+ kind: "Apply",
1708
+ operator: token.text,
1709
+ args: [left, right],
1710
+ location: getLocation(token),
1711
+ };
1712
+ }),
1713
+ )
1714
+ : undefined;
1715
+
1716
+ const parseTlapmItem = (isStart: boolean): TlapmItem | undefined => {
1717
+ const start = cursor;
1718
+ const token = peek();
1719
+ const location = getLocation(token);
1720
+ const isOperator = token.kind === "Operator" || token.kind === "Keyword";
1721
+ const infix = isOperator ? INFIX_OPERATORS.get(token.text) : undefined;
1722
+ if (!isStart) {
1723
+ if (isAt("[")) {
1724
+ const args = parseFunctionArguments();
1725
+ return getTlapmOperator(start, "Postfix", TLAPM_SELECTION_PRECEDENCE, (operands) => ({
1726
+ kind: "FunctionApplication",
1727
+ function: operands[0].expression,
1728
+ args,
1729
+ location,
1730
+ }));
1731
+ }
1732
+ if (isAt(".") && isFieldName(peek(1))) {
1733
+ advance();
1734
+ const field = advance().text;
1735
+ return getTlapmOperator(start, "Postfix", TLAPM_SELECTION_PRECEDENCE, (operands) => ({
1736
+ kind: "FieldAccess",
1737
+ record: operands[0].expression,
1738
+ field,
1429
1739
  location,
1740
+ }));
1741
+ }
1742
+ if (infix) {
1743
+ // Pco.resolve has no operator to put before that atom, so the expression ends here.
1744
+ if (parseTlapmNonfixInfix(token)) {
1745
+ cursor = start;
1746
+ return undefined;
1747
+ }
1748
+ advance();
1749
+ return {
1750
+ ...getTlapmOperator(start, "Infix", infix, (operands) =>
1751
+ getInfixApplication(
1752
+ token,
1753
+ operands[0].expression,
1754
+ operands[1].expression,
1755
+ operands[0].joinedBy === token.text,
1756
+ getRange(operands[0].start, operands[1].end).end,
1757
+ ),
1758
+ ),
1759
+ isLeft: isTlapmLeft(token.text, infix),
1760
+ joins: token.text,
1430
1761
  };
1431
1762
  }
1432
- left = withRange(left, start);
1433
- previous = { ...infix, text: token.text };
1763
+ if (token.kind !== "Operator" || !DEFINABLE_POSTFIX_OPERATORS.has(token.text))
1764
+ return undefined;
1765
+ // Pco.resolve has no operator to put before that atom, so the expression ends here.
1766
+ if (parseTlapmNonfixPostfix(token)) {
1767
+ cursor = start;
1768
+ return undefined;
1769
+ }
1770
+ advance();
1771
+ return getTlapmOperator(start, "Postfix", POSTFIX_PRECEDENCE, (operands) =>
1772
+ getPostfixApplication(token, operands[0].expression),
1773
+ );
1434
1774
  }
1435
- return left;
1775
+ if (token.kind === "Operator" && isBullet(token))
1776
+ return getTlapmOperand(parseJunctionList(), start);
1777
+ const nonfix = infix ? parseTlapmNonfixInfix(token) : undefined;
1778
+ if (nonfix) return getTlapmOperand(nonfix, start);
1779
+ const nonfixPostfix = parseTlapmNonfixPostfix(token);
1780
+ if (nonfixPostfix) {
1781
+ nonfixPostfix.expression.location.range = getRange(start, nonfixPostfix.end);
1782
+ return { start, end: nonfixPostfix.end, expression: nonfixPostfix.expression };
1783
+ }
1784
+ const prefix = isOperator ? TLAPM_PREFIX_OPERATORS.get(token.text) : undefined;
1785
+ if (prefix) {
1786
+ advance();
1787
+ return getTlapmOperator(start, "Prefix", prefix, (operands) =>
1788
+ getOperatorApplication(
1789
+ token.text === "-" ? "-." : token.text,
1790
+ operands[0].expression,
1791
+ location,
1792
+ ),
1793
+ );
1794
+ }
1795
+ if (!isTlapmAtomStart(token)) return undefined;
1796
+ const isTransparent = token.kind === "Operator" && TLAPM_OPEN_BRACKETS.has(token.text);
1797
+ return getTlapmOperand(isTransparent ? parsePrimary() : commit(parsePrimary), start);
1798
+ };
1799
+
1800
+ const isTlapmOperator = (item: TlapmItem | undefined): item is TlapmOperator =>
1801
+ item !== undefined && "fixity" in item;
1802
+
1803
+ const isTlapmOperand = (item: TlapmItem | undefined): item is TlapmOperand =>
1804
+ item !== undefined && !("fixity" in item);
1805
+
1806
+ const applyTlapmOperator = (operator: TlapmOperator, operands: TlapmOperand[]) => {
1807
+ const start = Math.min(operator.start, operands[0].start);
1808
+ const end = Math.max(operator.end, operands[operands.length - 1].end);
1809
+ const expression = operator.apply(operands);
1810
+ expression.location.range = getRange(start, end);
1811
+ return { start, end, expression, joinedBy: operator.joins };
1812
+ };
1813
+
1814
+ const reduceTlapmItems = (stack: TlapmItem[]) => {
1815
+ const right = stack.pop();
1816
+ const operator = stack.pop();
1817
+ if (!isTlapmOperand(right) || !isTlapmOperator(operator)) {
1818
+ throw createError("incomplete expression");
1819
+ }
1820
+ const left = operator.fixity === "Infix" ? stack.pop() : undefined;
1821
+ stack.push(applyTlapmOperator(operator, isTlapmOperand(left) ? [left, right] : [right]));
1436
1822
  };
1437
1823
 
1824
+ const getPreviousOperator = (stack: TlapmItem[]) => {
1825
+ const previous = stack[stack.length - 2];
1826
+ return isTlapmOperator(previous) ? previous : undefined;
1827
+ };
1828
+
1829
+ const isBelow = (left: Precedence, right: Precedence | undefined) =>
1830
+ right !== undefined && left.high < right.low;
1831
+
1832
+ // Port of Pco.resolve. A failure after the first item backtracks no further than its attempt.
1833
+ const parseTlapmExpression = (): Expression =>
1834
+ withRestorePoint(() => {
1835
+ const first = attempt(() => parseTlapmItem(true));
1836
+ if (first === undefined) {
1837
+ const token = peekRaw();
1838
+ throw token.kind === "End"
1839
+ ? createUnexpected("Unexpected end of expression", token)
1840
+ : createError(`required expressions(s) missing before '${getTlapmName(token)}'`, token);
1841
+ }
1842
+ return commit(() => {
1843
+ const stack = [first];
1844
+ while (true) {
1845
+ const item = attempt(() => parseTlapmItem(isTlapmOperator(stack[stack.length - 1])));
1846
+ if (item === undefined) break;
1847
+ if (isTlapmOperand(item) || item.fixity === "Prefix") {
1848
+ stack.push(item);
1849
+ continue;
1850
+ }
1851
+ while (isBelow(item, getPreviousOperator(stack))) reduceTlapmItems(stack);
1852
+ const operand = stack[stack.length - 1];
1853
+ if (item.fixity === "Postfix" && isTlapmOperand(operand)) {
1854
+ stack.splice(-1, 1, applyTlapmOperator(item, [operand]));
1855
+ continue;
1856
+ }
1857
+ const previous = getPreviousOperator(stack);
1858
+ const isLeftChain =
1859
+ previous?.fixity === "Infix" &&
1860
+ previous.isLeft &&
1861
+ item.isLeft &&
1862
+ !isBelow(previous, item);
1863
+ if (isLeftChain) reduceTlapmItems(stack);
1864
+ stack.push(item);
1865
+ }
1866
+ while (stack.length > 1) reduceTlapmItems(stack);
1867
+ const result = stack[0];
1868
+ if (!isTlapmOperand(result)) throw createError("incomplete expression");
1869
+ return result.expression;
1870
+ });
1871
+ });
1872
+
1873
+ const parseExpression = (minimumPrecedence = 0) =>
1874
+ isTlapm ? parseTlapmExpression() : parseSanyExpression(minimumPrecedence);
1875
+
1438
1876
  const parseParams = () => {
1439
1877
  if (!accept("(")) return [];
1440
1878
  const params = parseDeclarations();
@@ -1566,7 +2004,11 @@ const parse = (
1566
2004
 
1567
2005
  const parseDeclarationUnit = (): Declaration => {
1568
2006
  const location = getLocation(peek());
1569
- if (isAt("_") && peek(1).kind === "Operator") {
2007
+ const isOperatorDeclaration =
2008
+ isAt("_") &&
2009
+ peek(1).kind === "Operator" &&
2010
+ (INFIX_OPERATORS.has(peek(1).text) || DEFINABLE_POSTFIX_OPERATORS.has(peek(1).text));
2011
+ if (isOperatorDeclaration) {
1570
2012
  advance();
1571
2013
  const name = advance().text;
1572
2014
  return { name, arity: accept("_") ? 2 : 1, location };
@@ -1679,23 +2121,6 @@ const parse = (
1679
2121
  return isFirst ? level > outer : proofLevels[top] === level;
1680
2122
  };
1681
2123
 
1682
- const isDeclared = (name: string) =>
1683
- !factNames.has(name) &&
1684
- openModules.some(
1685
- (module) =>
1686
- module.constants.some((constant) => constant.name === name) ||
1687
- module.variables.some((variable) => variable.name === name) ||
1688
- module.definitions.some((definition) => definition.name === name),
1689
- );
1690
-
1691
- const isHideFact = (fact: Fact) => {
1692
- if (fact.kind === "ModuleFact" || fact.kind === "Subexpression") return true;
1693
- if (fact.kind === "Apply") return fact.operator.includes("!");
1694
- if (fact.kind !== "Identifier") return false;
1695
- if (fact.name.startsWith("<") || fact.name.includes("!")) return true;
1696
- return !BUILTIN_CONSTANTS.has(fact.name) && !isDeclared(fact.name);
1697
- };
1698
-
1699
2124
  const isFactAhead = () => {
1700
2125
  const token = peek();
1701
2126
  if (token.kind === "Step") return isStepReference(token);
@@ -1732,23 +2157,6 @@ const parse = (
1732
2157
  );
1733
2158
  };
1734
2159
 
1735
- const declareProofSymbol = (name: string) => proofScopes[proofScopes.length - 1]?.add(name);
1736
-
1737
- const withProofScope = <Result>(parse: () => Result) => {
1738
- proofScopes.push(new Set());
1739
- const result = parse();
1740
- proofScopes.pop();
1741
- return result;
1742
- };
1743
-
1744
- const isDeclaredSymbol = (name: string) =>
1745
- proofScopes.some((scope) => scope.has(name)) ||
1746
- openModules.some(
1747
- (module) =>
1748
- module.constants.some((constant) => constant.name === name) ||
1749
- module.variables.some((variable) => variable.name === name),
1750
- );
1751
-
1752
2160
  const parseDefinable = (): Fact => {
1753
2161
  const start = cursor;
1754
2162
  const token = peek();
@@ -1770,21 +2178,44 @@ const parse = (
1770
2178
  );
1771
2179
  };
1772
2180
 
1773
- const parseDefs = () => {
1774
- if (isTlapm) return parseSeparated(parseDefinable);
1775
- const defs = parseSeparated(parseFact);
1776
- const invalid =
1777
- mode === "tlc"
1778
- ? defs.find((def) => def.kind === "Identifier" && isDeclaredSymbol(def.name))
1779
- : undefined;
1780
- if (invalid) {
1781
- throw createError("DEF clause entry should describe a defined operator", invalid.location);
1782
- }
1783
- return defs;
2181
+ const parseDefs = () =>
2182
+ parseSeparated(() => {
2183
+ if (isTlapm) return parseDefinable();
2184
+ const fact = parseFact();
2185
+ const isName =
2186
+ (fact.kind === "Identifier" ||
2187
+ fact.kind === "Subexpression" ||
2188
+ fact.kind === "OperatorReference") &&
2189
+ !parenthesizedRanges.has(fact);
2190
+ if (fact.kind !== "ModuleFact" && !isName) {
2191
+ defEntryErrors.set(
2192
+ fact,
2193
+ getDefEntryErrors(createSourceFile(openModules[0].name, source), fact),
2194
+ );
2195
+ }
2196
+ return fact;
2197
+ });
2198
+
2199
+ // tlapm's usebody reads facts while an expression starts after the comma.
2200
+ const parseTlapmFacts = (): Fact[] => {
2201
+ const first = attempt(parseExpression);
2202
+ if (!first) return [];
2203
+ const facts = [first];
2204
+ withRestorePoint(() => {
2205
+ while (isAt(",")) {
2206
+ const fact = attempt(() => {
2207
+ advance();
2208
+ return parseExpression();
2209
+ });
2210
+ if (!fact) return;
2211
+ facts.push(fact);
2212
+ }
2213
+ });
2214
+ return facts;
1784
2215
  };
1785
2216
 
1786
2217
  const parseFacts = () => {
1787
- const facts = isFactAhead() ? parseSeparated(parseFact) : [];
2218
+ const facts = isTlapm ? parseTlapmFacts() : isFactAhead() ? parseSeparated(parseFact) : [];
1788
2219
  const isDef = accept("DEF") || accept("DEFS");
1789
2220
  if (isTlapm && facts.length === 0 && !isDef) throw createUnexpected("Expected a fact");
1790
2221
  return { facts, defs: isDef ? parseDefs() : [] };
@@ -1795,25 +2226,16 @@ const parse = (
1795
2226
  const keyword = advance();
1796
2227
  const isOnly = keyword.text === "USE" && accept("ONLY");
1797
2228
  const keywordRange = getRange(start);
1798
- const use: UseOrHide = {
1799
- kind: keyword.text === "USE" ? "Use" : "Hide",
1800
- isOnly,
1801
- ...parseFacts(),
1802
- keyword: keywordRange,
1803
- location: getLocation(keyword),
1804
- };
1805
- const invalid =
1806
- use.kind === "Hide" && mode === "tlc" ? use.facts.filter((fact) => !isHideFact(fact)) : [];
1807
- if (invalid.length > 0) {
1808
- throw createSanyError(
1809
- invalid.map((fact) => ({
1810
- location: formatRange(fact.location.range ?? getRange(start)),
1811
- message:
1812
- "The only expression allowed as a fact in a HIDE is \nthe name of a theorem, assumption, or step.",
1813
- })),
1814
- );
1815
- }
1816
- return withRange(use, start);
2229
+ return withRange(
2230
+ {
2231
+ kind: keyword.text === "USE" ? "Use" : "Hide",
2232
+ isOnly,
2233
+ ...parseFacts(),
2234
+ keyword: keywordRange,
2235
+ location: getLocation(keyword),
2236
+ },
2237
+ start,
2238
+ );
1817
2239
  };
1818
2240
 
1819
2241
  const parseNewSymbol = (): NewSymbol => {
@@ -1829,7 +2251,6 @@ const parse = (
1829
2251
  if (level !== undefined) advance();
1830
2252
  if (level === "Variable") {
1831
2253
  const named = expectName();
1832
- declareProofSymbol(named.name);
1833
2254
  return withRange(
1834
2255
  {
1835
2256
  kind: "NewSymbol",
@@ -1844,7 +2265,6 @@ const parse = (
1844
2265
  );
1845
2266
  }
1846
2267
  const declaration = parseDeclaration();
1847
- declareProofSymbol(declaration.name);
1848
2268
  const isBounded = (level ?? "Constant") === "Constant" && isAt("\\in");
1849
2269
  if (isBounded && declaration.arity > 0) {
1850
2270
  throw createError("declared symbol with arguments before \\in");
@@ -1864,23 +2284,50 @@ const parse = (
1864
2284
  );
1865
2285
  };
1866
2286
 
2287
+ const parseHypothesis = () => {
2288
+ if (peek().kind === "Identifier" && isAt("::", 1) && isAt("ASSUME", 2)) {
2289
+ advance();
2290
+ advance();
2291
+ }
2292
+ if (isAt("ASSUME")) return parseAssumeProve();
2293
+ if (peek().kind === "Keyword" && NEW_SYMBOL_STARTS.has(peek().text))
2294
+ return isTlapm ? commit(parseNewSymbol) : parseNewSymbol();
2295
+ if (!isTlapm) return parseExpression();
2296
+ // expr_or_sequent: where no expression starts, the sequent's ASSUME fails last.
2297
+ const expression = attempt(parseExpression);
2298
+ if (expression === undefined) throw createUnexpected("Expected a hypothesis");
2299
+ return expression;
2300
+ };
2301
+
2302
+ // comma1 (hyp b): Pco.star attempts the hypotheses after the first, each inside the one before,
2303
+ // so a failure that backtracks ends the list, and tlapm reports any other before the first comma.
2304
+ const parseTlapmHypotheses = () => {
2305
+ const assumptions = [parseHypothesis()];
2306
+ withRestorePoint(() => {
2307
+ while (true) {
2308
+ const assumption = attempt(() => {
2309
+ expect(",");
2310
+ return parseHypothesis();
2311
+ });
2312
+ if (assumption === undefined) break;
2313
+ assumptions.push(assumption);
2314
+ }
2315
+ });
2316
+ return assumptions;
2317
+ };
2318
+
1867
2319
  const parseAssumeProve = (): AssumeProve => {
1868
2320
  const start = cursor;
1869
2321
  const location = getLocation(expect("ASSUME"));
1870
- const assumptions = parseSeparated(() => {
1871
- if (peek().kind === "Identifier" && isAt("::", 1) && isAt("ASSUME", 2)) {
1872
- advance();
1873
- advance();
1874
- }
1875
- if (isAt("ASSUME")) return withProofScope(parseAssumeProve);
1876
- if (peek().kind === "Keyword" && NEW_SYMBOL_STARTS.has(peek().text)) return parseNewSymbol();
1877
- return parseExpression();
1878
- });
1879
- expect("PROVE");
1880
- return withRange(
1881
- { kind: "AssumeProve", assumptions, conclusion: parseExpression(), location },
1882
- start,
1883
- );
2322
+ const parseSequent = (): AssumeProve => {
2323
+ const assumptions = isTlapm ? parseTlapmHypotheses() : parseSeparated(parseHypothesis);
2324
+ expect("PROVE");
2325
+ return withRange(
2326
+ { kind: "AssumeProve", assumptions, conclusion: parseExpression(), location },
2327
+ start,
2328
+ );
2329
+ };
2330
+ return isTlapm ? commit(parseSequent) : parseSequent();
1884
2331
  };
1885
2332
 
1886
2333
  const isNameListAhead = (terminator: string) => {
@@ -1891,19 +2338,10 @@ const parse = (
1891
2338
  return peek(offset).kind === "Identifier" && isAt(terminator, offset + 1);
1892
2339
  };
1893
2340
 
1894
- const declareProofSymbols = (names: string[], bounds: Bound[]) => {
1895
- names.forEach(declareProofSymbol);
1896
- bounds.forEach((bound) =>
1897
- (bound.pattern.kind === "Name" ? [bound.pattern.name] : bound.pattern.names).forEach(
1898
- declareProofSymbol,
1899
- ),
1900
- );
1901
- };
1902
-
1903
2341
  const parseStepBody = (): StepBody => {
1904
2342
  const token = peek();
1905
2343
  if (isAt("USE") || isAt("HIDE")) return parseUseOrHide();
1906
- if (isAt("INSTANCE")) {
2344
+ if (!isTlapm && isAt("INSTANCE")) {
1907
2345
  const start = cursor;
1908
2346
  return withRange(parseInstance(undefined, [], false, getLocation(token)), start);
1909
2347
  }
@@ -1920,7 +2358,6 @@ const parse = (
1920
2358
  const isBounded = isBoundAhead();
1921
2359
  const names = getNames(isBounded ? [] : parseSeparated(expectName));
1922
2360
  const bounds = isBounded ? parseBounds() : [];
1923
- declareProofSymbols(names.names, bounds);
1924
2361
  return { kind: "Take", names: names.names, nameRanges: names.ranges, bounds };
1925
2362
  }
1926
2363
  if (accept("WITNESS")) {
@@ -1930,7 +2367,6 @@ const parse = (
1930
2367
  const isNames = isNameListAhead(":");
1931
2368
  const names = getNames(isNames ? parseSeparated(expectName) : []);
1932
2369
  const bounds = isNames ? [] : parseBounds();
1933
- declareProofSymbols(names.names, bounds);
1934
2370
  expect(":");
1935
2371
  return {
1936
2372
  kind: "Pick",
@@ -1967,8 +2403,6 @@ const parse = (
1967
2403
  const start = cursor;
1968
2404
  const step = parseStepStart(isAt("QED", 1));
1969
2405
  const statementStart = cursor;
1970
- const scope = new Set<string>();
1971
- proofScopes.push(scope);
1972
2406
  const body: StepBody = accept("QED") ? { kind: "Qed" } : parseStepBody();
1973
2407
  const head = getRange(start);
1974
2408
  const statement = getRange(statementStart);
@@ -1977,8 +2411,6 @@ const parse = (
1977
2411
  throw createError("Proof of a step that does not take a proof");
1978
2412
  }
1979
2413
  const proof = hasProof ? parseProof() : undefined;
1980
- proofScopes.pop();
1981
- if (body.kind !== "Assert" || body.isSuffices) scope.forEach(declareProofSymbol);
1982
2414
  return withRange({ ...step, body, head, statement, proof }, start);
1983
2415
  };
1984
2416
 
@@ -2010,7 +2442,7 @@ const parse = (
2010
2442
  const parseProof = (): Proof => {
2011
2443
  const start = cursor;
2012
2444
  proofLevels.push(-1);
2013
- const proof = withProofScope(parseProofBody);
2445
+ const proof = parseProofBody();
2014
2446
  proofLevels.pop();
2015
2447
  return withRange(proof, start);
2016
2448
  };
@@ -2092,20 +2524,26 @@ const parse = (
2092
2524
  throw createProofError(
2093
2525
  `Unexpected end of (sub)proof at level ${level} before QED step`,
2094
2526
  levelSpan,
2527
+ NEWLINES,
2095
2528
  );
2096
2529
  }
2097
2530
  if (item.kind === "Leaf") {
2098
2531
  throw createProofError(
2099
2532
  `Expecting a proof step but found a${LEAF_NAMES[item.proof.kind]} leaf proof`,
2100
2533
  item.span,
2534
+ NEWLINES,
2101
2535
  );
2102
2536
  }
2103
2537
  if (!isFirst && item.isProof) {
2104
- throw createProofError("PROOF keyword found in step that does not begin subproof", item.span);
2538
+ throw createProofError(
2539
+ "PROOF keyword found in step that does not begin subproof",
2540
+ item.span,
2541
+ PRINTED_NEWLINE,
2542
+ );
2105
2543
  }
2106
2544
  const implicit = item.token.text[1];
2107
2545
  if (implicit === "+" && !isFirst) {
2108
- throw createProofError("<+> used but no subproof expected", item.span);
2546
+ throw createProofError("<+> used but no subproof expected", item.span, PRINTED_NEWLINE);
2109
2547
  }
2110
2548
  const stepLevel =
2111
2549
  implicit === "*"
@@ -2160,57 +2598,58 @@ const parse = (
2160
2598
  throw createProofError(
2161
2599
  "extra step(s) after finished proof",
2162
2600
  extra.span,
2601
+ NO_NEWLINES,
2163
2602
  "Proof.Parser.toplevel",
2164
2603
  );
2165
2604
  }
2166
2605
  return nested.proof;
2167
2606
  };
2168
2607
 
2169
- const addFactDefinition = (module: Module, definition: Definition) => {
2170
- if (module.definitions.some((other) => other.name === definition.name)) return;
2171
- module.definitions.push(definition);
2608
+ const addFactDefinition = (
2609
+ module: Module,
2610
+ name: string,
2611
+ body: Expression,
2612
+ location: SourceLocation,
2613
+ ) => {
2614
+ if (module.definitions.some((other) => other.name === name)) return;
2615
+ module.definitions.push({
2616
+ kind: "Operator",
2617
+ name,
2618
+ params: [],
2619
+ body,
2620
+ isLocal: false,
2621
+ isRecursive: false,
2622
+ location,
2623
+ });
2172
2624
  };
2173
2625
 
2174
2626
  const parseFactName = () => {
2175
2627
  if (peek().kind !== "Identifier" || !isAt("==", 1)) return undefined;
2176
2628
  const name = expectIdentifier();
2177
- factNames.add(name);
2178
2629
  advance();
2179
2630
  return name;
2180
2631
  };
2181
2632
 
2633
+ // A theorem whose statement fails to start backtracks in tlapm, whose module ends there.
2634
+ const parseTheoremExpression = () => {
2635
+ if (!isTlapm) return parseExpression();
2636
+ const token = peekRaw();
2637
+ const statement = attempt(parseExpression);
2638
+ if (statement) return statement;
2639
+ throw createUnexpected(`Expected "====" but found ${describeToken(token)}`, token);
2640
+ };
2641
+
2182
2642
  const parseTheorem = (module: Module) => {
2183
2643
  const start = cursor;
2184
2644
  const keyword = advance();
2185
2645
  const name = parseFactName();
2186
- const parsed = withProofScope(() => {
2187
- const statement = isAt("ASSUME") ? parseAssumeProve() : parseExpression();
2188
- if (isTlapm) return { statement, proof: parseTlapmProof() };
2189
- return { statement, proof: isProofStart(peek()) ? parseProof() : undefined };
2190
- });
2191
- const statement = parsed.statement;
2192
- const theorem = withRange(
2193
- { name, statement, proof: parsed.proof, location: getLocation(keyword) },
2194
- start,
2195
- );
2646
+ const statement = isAt("ASSUME") ? parseAssumeProve() : parseTheoremExpression();
2647
+ const proof = isTlapm ? parseTlapmProof() : isProofStart(peek()) ? parseProof() : undefined;
2648
+ const theorem = withRange({ name, statement, proof, location: getLocation(keyword) }, start);
2196
2649
  module.theorems.push(theorem);
2197
2650
  module.units.push({ kind: "Theorem", theorem });
2198
2651
  if (name === undefined || statement.kind === "AssumeProve") return;
2199
- addFactDefinition(
2200
- module,
2201
- withRange(
2202
- {
2203
- kind: "Operator",
2204
- name,
2205
- params: [],
2206
- body: statement,
2207
- isLocal: false,
2208
- isRecursive: false,
2209
- location: getLocation(keyword),
2210
- },
2211
- start,
2212
- ),
2213
- );
2652
+ addFactDefinition(module, name, statement, theorem.location);
2214
2653
  };
2215
2654
 
2216
2655
  const parseAssumption = (): Assumption => {
@@ -2247,6 +2686,7 @@ const parse = (
2247
2686
  theorems: [],
2248
2687
  uses: [],
2249
2688
  units: [],
2689
+ hasRecursiveLet: false,
2250
2690
  };
2251
2691
  openModules.push(module);
2252
2692
  recursiveScopes.push(new Set());
@@ -2259,7 +2699,6 @@ const parse = (
2259
2699
  }
2260
2700
  while (true) {
2261
2701
  const tokenIndex = cursor;
2262
- unitStart = tokenIndex;
2263
2702
  const token = peek();
2264
2703
  if (token.kind === "ModuleEnd") {
2265
2704
  location.range = {
@@ -2312,15 +2751,7 @@ const parse = (
2312
2751
  module.assumptions.push(assumption);
2313
2752
  module.units.push({ kind: "Assumption", assumption });
2314
2753
  if (assumption.name !== undefined) {
2315
- addFactDefinition(module, {
2316
- kind: "Operator",
2317
- name: assumption.name,
2318
- params: [],
2319
- body: assumption.expression,
2320
- isLocal: false,
2321
- isRecursive: false,
2322
- location: assumption.location,
2323
- });
2754
+ addFactDefinition(module, assumption.name, assumption.expression, assumption.location);
2324
2755
  }
2325
2756
  continue;
2326
2757
  }