tla-ts 0.0.10-dev.63a6693bd → 0.0.10-dev.6b2a6741a

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 (551) hide show
  1. package/README.md +2 -1
  2. package/dist/compile.cjs +3 -3
  3. package/dist/compile.js +1 -1
  4. package/dist/deciders.cjs +41 -37
  5. package/dist/deciders.js +45 -41
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +5 -1
  8. package/dist/index.d.ts +5 -1
  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 +2682 -426
  15. package/dist/prove.js +2679 -423
  16. package/dist/run.cjs +43 -42
  17. package/dist/run.js +44 -43
  18. package/dist/tlapm.cjs +1 -1
  19. package/dist/tlapm.js +1 -1
  20. package/dist/transfer.cjs +43 -40
  21. package/dist/transfer.js +43 -40
  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 +4 -3
  26. package/src/bags.ts +46 -28
  27. package/src/check-trace.ts +2 -16
  28. package/src/check.ts +349 -91
  29. package/src/cli/runtime-invariants.ts +20 -56
  30. package/src/cli/tlapm.ts +424 -62
  31. package/src/cli/tlc-arguments.ts +2 -2
  32. package/src/cli/tlc-output.ts +4 -5
  33. package/src/cli/tlc-usage.ts +0 -1
  34. package/src/cli/tlc.ts +26 -7
  35. package/src/cli/xml-exporter.ts +1 -1
  36. package/src/codegen.ts +9 -5
  37. package/src/dependencies.ts +72 -11
  38. package/src/dfid.ts +9 -2
  39. package/src/environment.ts +65 -36
  40. package/src/errors.ts +38 -3
  41. package/src/evaluate.ts +92 -32
  42. package/src/exit-codes.ts +5 -2
  43. package/src/instances.ts +5 -5
  44. package/src/java-overrides.ts +2 -2
  45. package/src/levels.ts +138 -90
  46. package/src/lexer.ts +5 -3
  47. package/src/liveness-checker.ts +572 -204
  48. package/src/liveness.ts +47 -32
  49. package/src/obligations/action.ts +10 -6
  50. package/src/obligations/anonymize.ts +33 -14
  51. package/src/obligations/enabled-axioms.ts +218 -0
  52. package/src/obligations/equality.ts +1 -3
  53. package/src/obligations/expression.ts +18 -6
  54. package/src/obligations/format.ts +0 -2
  55. package/src/obligations/generate.ts +22 -17
  56. package/src/obligations/index.ts +37 -7
  57. package/src/obligations/levels.ts +24 -11
  58. package/src/obligations/module.ts +1 -3
  59. package/src/obligations/normalize.ts +25 -17
  60. package/src/obligations/operators.ts +0 -2
  61. package/src/obligations/pragma.ts +53 -16
  62. package/src/obligations/printer.ts +48 -18
  63. package/src/obligations/proof.ts +3 -2
  64. package/src/obligations/regroup.ts +0 -2
  65. package/src/obligations/simplify.ts +17 -7
  66. package/src/obligations/source.ts +71 -17
  67. package/src/obligations/subexpression.ts +45 -18
  68. package/src/obligations/substitution.ts +1 -3
  69. package/src/obligations/temporal.ts +0 -2
  70. package/src/obligations/tuples.ts +0 -2
  71. package/src/parallel-worker.ts +8 -2
  72. package/src/parallel.ts +7 -2
  73. package/src/parser.ts +664 -287
  74. package/src/pretty-print.ts +1 -1
  75. package/src/prover/deciders.ts +11 -8
  76. package/src/prover/isabelle/decide.ts +3 -25
  77. package/src/prover/isabelle/encode.ts +71 -41
  78. package/src/prover/isabelle/isar/attrib.ts +250 -0
  79. package/src/prover/isabelle/isar/context.ts +335 -0
  80. package/src/prover/isabelle/isar/induct.ts +382 -0
  81. package/src/prover/isabelle/isar/inner-syntax.ts +149 -3
  82. package/src/prover/isabelle/isar/method.ts +506 -198
  83. package/src/prover/isabelle/isar/proof.ts +570 -14
  84. package/src/prover/isabelle/isar/rule-cases.ts +226 -0
  85. package/src/prover/isabelle/isar/theory.ts +479 -69
  86. package/src/prover/isabelle/isar/toplevel.ts +331 -0
  87. package/src/prover/isabelle/isar/type-check.ts +83 -8
  88. package/src/prover/isabelle/provers/blast/blast.ts +0 -2
  89. package/src/prover/isabelle/provers/blast/branch.ts +0 -2
  90. package/src/prover/isabelle/provers/blast/prove.ts +0 -2
  91. package/src/prover/isabelle/provers/blast/rules.ts +0 -2
  92. package/src/prover/isabelle/provers/blast/state.ts +0 -2
  93. package/src/prover/isabelle/provers/blast/term.ts +0 -2
  94. package/src/prover/isabelle/provers/clasimp.ts +1 -3
  95. package/src/prover/isabelle/provers/classical.ts +45 -20
  96. package/src/prover/isabelle/provers/hypsubst.ts +2 -4
  97. package/src/prover/isabelle/pure/bicompose.ts +0 -2
  98. package/src/prover/isabelle/pure/consts.ts +0 -2
  99. package/src/prover/isabelle/pure/conv.ts +0 -2
  100. package/src/prover/isabelle/pure/drule.ts +63 -4
  101. package/src/prover/isabelle/pure/envir.ts +0 -2
  102. package/src/prover/isabelle/pure/goal.ts +1 -3
  103. package/src/prover/isabelle/pure/logic.ts +0 -2
  104. package/src/prover/isabelle/pure/name.ts +0 -2
  105. package/src/prover/isabelle/pure/net.ts +0 -2
  106. package/src/prover/isabelle/pure/object-logic.ts +13 -7
  107. package/src/prover/isabelle/pure/pattern.ts +0 -2
  108. package/src/prover/isabelle/pure/raw-simplifier.ts +0 -2
  109. package/src/prover/isabelle/pure/rewriter.ts +4 -11
  110. package/src/prover/isabelle/pure/search.ts +0 -2
  111. package/src/prover/isabelle/pure/seq.ts +0 -2
  112. package/src/prover/isabelle/pure/simplifier.ts +26 -7
  113. package/src/prover/isabelle/pure/table.ts +0 -2
  114. package/src/prover/isabelle/pure/tactic.ts +0 -2
  115. package/src/prover/isabelle/pure/tactical.ts +0 -2
  116. package/src/prover/isabelle/pure/term-ord.ts +0 -2
  117. package/src/prover/isabelle/pure/term.ts +3 -5
  118. package/src/prover/isabelle/pure/thm.ts +0 -2
  119. package/src/prover/isabelle/pure/type.ts +0 -2
  120. package/src/prover/isabelle/pure/unify.ts +0 -2
  121. package/src/prover/isabelle/pure/variable.ts +0 -2
  122. package/src/prover/isabelle/tla/classical-setup.ts +1 -2
  123. package/src/prover/isabelle/tla/context.ts +51 -9
  124. package/src/prover/isabelle/tla/logic-data.ts +1 -1
  125. package/src/prover/isabelle/tla/logic.ts +40 -1
  126. package/src/prover/isabelle/tla/simpdata.ts +0 -2
  127. package/src/prover/isabelle/tools/intuitionistic.ts +28 -12
  128. package/src/prover/ocaml.ts +4 -1
  129. package/src/prover/prep/action.ts +19 -12
  130. package/src/prover/prep/enabled-axioms.ts +11 -2
  131. package/src/prover/prep/md5.ts +26 -29
  132. package/src/prover/prep/methods.ts +159 -50
  133. package/src/prover/prep/normalize.ts +38 -9
  134. package/src/prover/prove.ts +343 -65
  135. package/src/prover/ptl/decide.ts +95 -50
  136. package/src/prover/ptl/encode.ts +2 -3
  137. package/src/prover/ptl/tableau.ts +28 -2
  138. package/src/prover/smt/arithmetic.ts +310 -0
  139. package/src/prover/smt/axioms.ts +12 -8
  140. package/src/prover/smt/context.ts +42 -6
  141. package/src/prover/smt/data.ts +191 -84
  142. package/src/prover/smt/encode.ts +122 -43
  143. package/src/prover/smt/extensionality.ts +5 -3
  144. package/src/prover/smt/flatten.ts +4 -6
  145. package/src/prover/smt/format.ts +28 -4
  146. package/src/prover/smt/instances.ts +7 -1
  147. package/src/prover/smt/layout.ts +91 -0
  148. package/src/prover/smt/rewrite.ts +483 -116
  149. package/src/prover/smt/simplify.ts +441 -0
  150. package/src/prover/smt/solver/ackermannize-bv-tactic.ts +61 -0
  151. package/src/prover/smt/solver/ackr-helper.ts +179 -0
  152. package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
  153. package/src/prover/smt/solver/act-cache.ts +0 -1
  154. package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
  155. package/src/prover/smt/solver/aig-tactic.ts +52 -0
  156. package/src/prover/smt/solver/aig.ts +889 -0
  157. package/src/prover/smt/solver/arith-rewriter.ts +613 -6
  158. package/src/prover/smt/solver/arith-terms.ts +121 -0
  159. package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
  160. package/src/prover/smt/solver/array-rewriter.ts +309 -0
  161. package/src/prover/smt/solver/asserted-formulas.ts +93 -15
  162. package/src/prover/smt/solver/ast-lt.ts +165 -11
  163. package/src/prover/smt/solver/ast-util.ts +160 -2
  164. package/src/prover/smt/solver/ast.ts +1449 -41
  165. package/src/prover/smt/solver/auf-solver.ts +0 -1
  166. package/src/prover/smt/solver/bit-blast-tactic.ts +582 -0
  167. package/src/prover/smt/solver/bit-blaster.ts +871 -0
  168. package/src/prover/smt/solver/bound-manager.ts +196 -0
  169. package/src/prover/smt/solver/bound-simplifier.ts +600 -0
  170. package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
  171. package/src/prover/smt/solver/bv-decl-plugin.ts +341 -0
  172. package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
  173. package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
  174. package/src/prover/smt/solver/bv1-blast.ts +214 -0
  175. package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
  176. package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
  177. package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
  178. package/src/prover/smt/solver/card2bv.ts +109 -0
  179. package/src/prover/smt/solver/case-split-queue.ts +0 -2
  180. package/src/prover/smt/solver/cg-table.ts +39 -25
  181. package/src/prover/smt/solver/check-logic.ts +330 -0
  182. package/src/prover/smt/solver/clause.ts +0 -1
  183. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +278 -0
  184. package/src/prover/smt/solver/conflict-resolution.ts +78 -2
  185. package/src/prover/smt/solver/context.ts +533 -114
  186. package/src/prover/smt/solver/ctx-simplify.ts +21 -12
  187. package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
  188. package/src/prover/smt/solver/datatype-decl-plugin.ts +572 -0
  189. package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
  190. package/src/prover/smt/solver/demodulator.ts +786 -0
  191. package/src/prover/smt/solver/dependent-expr-state.ts +81 -0
  192. package/src/prover/smt/solver/der.ts +38 -10
  193. package/src/prover/smt/solver/diff-neq.ts +205 -0
  194. package/src/prover/smt/solver/distribute-forall.ts +57 -0
  195. package/src/prover/smt/solver/dom-simplify.ts +511 -0
  196. package/src/prover/smt/solver/dt2bv-tactic.ts +260 -0
  197. package/src/prover/smt/solver/dyn-ack.ts +0 -1
  198. package/src/prover/smt/solver/e-matching.ts +6 -7
  199. package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
  200. package/src/prover/smt/solver/elim-uncnstr.ts +542 -0
  201. package/src/prover/smt/solver/enode.ts +100 -3
  202. package/src/prover/smt/solver/eq2bv-tactic.ts +218 -0
  203. package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
  204. package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
  205. package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
  206. package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
  207. package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
  208. package/src/prover/smt/solver/euf/array-solver.ts +306 -0
  209. package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
  210. package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
  211. package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
  212. package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
  213. package/src/prover/smt/solver/euf/egraph.ts +901 -0
  214. package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
  215. package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
  216. package/src/prover/smt/solver/euf/mam.ts +1046 -0
  217. package/src/prover/smt/solver/euf/q-ematch.ts +829 -0
  218. package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
  219. package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
  220. package/src/prover/smt/solver/euf/q-solver.ts +361 -0
  221. package/src/prover/smt/solver/euf/th-solver.ts +328 -0
  222. package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
  223. package/src/prover/smt/solver/expr-ref.ts +0 -1
  224. package/src/prover/smt/solver/expr-safe-replace.ts +26 -2
  225. package/src/prover/smt/solver/expr2polynomial.ts +271 -0
  226. package/src/prover/smt/solver/factor.ts +163 -0
  227. package/src/prover/smt/solver/fd-solver.ts +267 -0
  228. package/src/prover/smt/solver/fingerprints.ts +15 -15
  229. package/src/prover/smt/solver/fix-dl-var.ts +147 -0
  230. package/src/prover/smt/solver/flat-literals.ts +0 -1
  231. package/src/prover/smt/solver/fm-tactic.ts +884 -0
  232. package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
  233. package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
  234. package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
  235. package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
  236. package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
  237. package/src/prover/smt/solver/goal.ts +177 -15
  238. package/src/prover/smt/solver/goal2nlsat.ts +216 -0
  239. package/src/prover/smt/solver/guard-set.ts +219 -0
  240. package/src/prover/smt/solver/hash.ts +0 -1
  241. package/src/prover/smt/solver/hashtable.ts +30 -16
  242. package/src/prover/smt/solver/inf-eps.ts +63 -0
  243. package/src/prover/smt/solver/inj-axiom.ts +101 -0
  244. package/src/prover/smt/solver/internalizer.ts +109 -36
  245. package/src/prover/smt/solver/lackr.ts +381 -0
  246. package/src/prover/smt/solver/lbool.ts +0 -1
  247. package/src/prover/smt/solver/lia2card.ts +268 -0
  248. package/src/prover/smt/solver/lia2pb.ts +154 -0
  249. package/src/prover/smt/solver/literal.ts +0 -1
  250. package/src/prover/smt/solver/logic-tactics.ts +345 -0
  251. package/src/prover/smt/solver/lp/bound-propagator.ts +0 -1
  252. package/src/prover/smt/solver/lp/constraints.ts +0 -1
  253. package/src/prover/smt/solver/lp/containers.ts +7 -2
  254. package/src/prover/smt/solver/lp/core-solver.ts +18 -3
  255. package/src/prover/smt/solver/lp/cross-nested.ts +1 -4
  256. package/src/prover/smt/solver/lp/dep-intervals.ts +0 -3
  257. package/src/prover/smt/solver/lp/dependency.ts +0 -2
  258. package/src/prover/smt/solver/lp/dioph-eq.ts +0 -2
  259. package/src/prover/smt/solver/lp/explanation.ts +0 -1
  260. package/src/prover/smt/solver/lp/gomory.ts +0 -1
  261. package/src/prover/smt/solver/lp/hnf-cutter.ts +0 -1
  262. package/src/prover/smt/solver/lp/hnf.ts +0 -3
  263. package/src/prover/smt/solver/lp/int-cube.ts +3 -4
  264. package/src/prover/smt/solver/lp/int-solver.ts +0 -2
  265. package/src/prover/smt/solver/lp/lar-solver.ts +40 -4
  266. package/src/prover/smt/solver/lp/lar-term.ts +0 -1
  267. package/src/prover/smt/solver/lp/lp-settings.ts +0 -1
  268. package/src/prover/smt/solver/lp/maximize-term.ts +59 -10
  269. package/src/prover/smt/solver/lp/nex-creator.ts +3 -3
  270. package/src/prover/smt/solver/lp/nex.ts +2 -2
  271. package/src/prover/smt/solver/lp/nla-backoff.ts +0 -2
  272. package/src/prover/smt/solver/lp/nla-basics.ts +46 -3
  273. package/src/prover/smt/solver/lp/nla-core.ts +66 -11
  274. package/src/prover/smt/solver/lp/nla-divisions.ts +0 -2
  275. package/src/prover/smt/solver/lp/nla-emonics.ts +0 -1
  276. package/src/prover/smt/solver/lp/nla-factorization.ts +0 -1
  277. package/src/prover/smt/solver/lp/nla-grobner.ts +167 -85
  278. package/src/prover/smt/solver/lp/nla-horner.ts +0 -2
  279. package/src/prover/smt/solver/lp/nla-intervals.ts +0 -1
  280. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +0 -2
  281. package/src/prover/smt/solver/lp/nla-monotone.ts +0 -1
  282. package/src/prover/smt/solver/lp/nla-order.ts +0 -2
  283. package/src/prover/smt/solver/lp/nla-patcher.ts +0 -1
  284. package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
  285. package/src/prover/smt/solver/lp/nla-tangents.ts +0 -2
  286. package/src/prover/smt/solver/lp/nla-throttle.ts +0 -1
  287. package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
  288. package/src/prover/smt/solver/lp/nla-types.ts +0 -2
  289. package/src/prover/smt/solver/lp/nla-var-eqs.ts +0 -1
  290. package/src/prover/smt/solver/lp/nra-solver.ts +163 -99
  291. package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
  292. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -3
  293. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -21
  294. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -41
  295. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  296. package/src/prover/smt/solver/lp/random-updater.ts +0 -2
  297. package/src/prover/smt/solver/lp/static-matrix.ts +0 -1
  298. package/src/prover/smt/solver/lp/union-find.ts +7 -2
  299. package/src/prover/smt/solver/macro-finder.ts +530 -0
  300. package/src/prover/smt/solver/mam-compiler.ts +118 -88
  301. package/src/prover/smt/solver/mam-interpreter.ts +0 -1
  302. package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
  303. package/src/prover/smt/solver/max-cliques.ts +105 -0
  304. package/src/prover/smt/solver/maxcore.ts +309 -0
  305. package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -6
  306. package/src/prover/smt/solver/maxlex.ts +115 -0
  307. package/src/prover/smt/solver/maxsmt-base.ts +105 -0
  308. package/src/prover/smt/solver/maxsmt.ts +92 -0
  309. package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
  310. package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
  311. package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
  312. package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
  313. package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
  314. package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
  315. package/src/prover/smt/solver/model-based-opt.ts +844 -0
  316. package/src/prover/smt/solver/model-checker.ts +17 -26
  317. package/src/prover/smt/solver/model-evaluator.ts +188 -12
  318. package/src/prover/smt/solver/model-finder.ts +0 -1
  319. package/src/prover/smt/solver/model-generator.ts +59 -30
  320. package/src/prover/smt/solver/model-macro-solver.ts +38 -27
  321. package/src/prover/smt/solver/model-printer.ts +214 -0
  322. package/src/prover/smt/solver/mpf.ts +709 -0
  323. package/src/prover/smt/solver/mus.ts +50 -0
  324. package/src/prover/smt/solver/muz/dl-context.ts +410 -0
  325. package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
  326. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
  327. package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
  328. package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
  329. package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
  330. package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
  331. package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
  332. package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
  333. package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
  334. package/src/prover/smt/solver/muz/dl-rule.ts +496 -0
  335. package/src/prover/smt/solver/muz/hnf.ts +201 -0
  336. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
  337. package/src/prover/smt/solver/muz/horn-tactic.ts +201 -0
  338. package/src/prover/smt/solver/muz/rule-properties.ts +337 -0
  339. package/src/prover/smt/solver/muz/spacer-context.ts +1404 -0
  340. package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
  341. package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
  342. package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
  343. package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
  344. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
  345. package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
  346. package/src/prover/smt/solver/muz/substitution.ts +203 -0
  347. package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
  348. package/src/prover/smt/solver/nlqsat.ts +484 -0
  349. package/src/prover/smt/solver/nlsat/algebraic.ts +305 -88
  350. package/src/prover/smt/solver/nlsat/atoms.ts +52 -35
  351. package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
  352. package/src/prover/smt/solver/nlsat/explain.ts +424 -211
  353. package/src/prover/smt/solver/nlsat/interval-set.ts +1 -2
  354. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -241
  355. package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
  356. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -683
  357. package/src/prover/smt/solver/nlsat/solver.ts +282 -69
  358. package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
  359. package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
  360. package/src/prover/smt/solver/nlsat/types.ts +0 -2
  361. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -7
  362. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -20
  363. package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
  364. package/src/prover/smt/solver/nnf.ts +105 -23
  365. package/src/prover/smt/solver/normalize-bounds.ts +53 -0
  366. package/src/prover/smt/solver/occf.ts +97 -0
  367. package/src/prover/smt/solver/opt-context.ts +792 -0
  368. package/src/prover/smt/solver/opt-nlsat.ts +386 -0
  369. package/src/prover/smt/solver/opt-pareto.ts +282 -0
  370. package/src/prover/smt/solver/opt-preprocess.ts +101 -0
  371. package/src/prover/smt/solver/opt-solver.ts +311 -0
  372. package/src/prover/smt/solver/opt-value.ts +55 -0
  373. package/src/prover/smt/solver/optsmt.ts +692 -0
  374. package/src/prover/smt/solver/parallel-tactic.ts +299 -0
  375. package/src/prover/smt/solver/pattern-inference.ts +19 -11
  376. package/src/prover/smt/solver/pb-rewriter.ts +281 -0
  377. package/src/prover/smt/solver/pb2bv-tactic.ts +540 -0
  378. package/src/prover/smt/solver/poly-rewriter.ts +202 -57
  379. package/src/prover/smt/solver/probes.ts +511 -0
  380. package/src/prover/smt/solver/propagate-values.ts +37 -21
  381. package/src/prover/smt/solver/proto-model.ts +650 -17
  382. package/src/prover/smt/solver/pull-quant.ts +28 -12
  383. package/src/prover/smt/solver/purify-arith.ts +632 -0
  384. package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -0
  385. package/src/prover/smt/solver/qe-lite-der.ts +2 -3
  386. package/src/prover/smt/solver/qe-lite-fm.ts +3 -4
  387. package/src/prover/smt/solver/qe-lite.ts +37 -17
  388. package/src/prover/smt/solver/qe-mbp.ts +270 -0
  389. package/src/prover/smt/solver/qe.ts +1499 -0
  390. package/src/prover/smt/solver/qel.ts +25 -0
  391. package/src/prover/smt/solver/qi-queue.ts +0 -1
  392. package/src/prover/smt/solver/qsat.ts +814 -0
  393. package/src/prover/smt/solver/quant-hoist.ts +196 -0
  394. package/src/prover/smt/solver/quant-tactics.ts +16 -56
  395. package/src/prover/smt/solver/quantifier-analyzer.ts +9 -10
  396. package/src/prover/smt/solver/quantifier-manager.ts +25 -24
  397. package/src/prover/smt/solver/quasi-macros.ts +243 -0
  398. package/src/prover/smt/solver/random-gen.ts +0 -1
  399. package/src/prover/smt/solver/rational.ts +45 -1
  400. package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -0
  401. package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
  402. package/src/prover/smt/solver/reduce-args.ts +225 -0
  403. package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
  404. package/src/prover/smt/solver/ref-vector.ts +0 -1
  405. package/src/prover/smt/solver/relevancy.ts +1 -2
  406. package/src/prover/smt/solver/rewriter-tpl.ts +77 -10
  407. package/src/prover/smt/solver/rewriter.ts +475 -36
  408. package/src/prover/smt/solver/rlimit.ts +38 -2
  409. package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
  410. package/src/prover/smt/solver/sat/big.ts +177 -0
  411. package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
  412. package/src/prover/smt/solver/sat/clause.ts +203 -0
  413. package/src/prover/smt/solver/sat/cleaner.ts +94 -0
  414. package/src/prover/smt/solver/sat/config.ts +122 -0
  415. package/src/prover/smt/solver/sat/consequences.ts +203 -0
  416. package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
  417. package/src/prover/smt/solver/sat/goal2sat.ts +526 -0
  418. package/src/prover/smt/solver/sat/inc-sat-solver.ts +378 -0
  419. package/src/prover/smt/solver/sat/model-converter.ts +136 -0
  420. package/src/prover/smt/solver/sat/pb-constraint.ts +261 -0
  421. package/src/prover/smt/solver/sat/pb-solver.ts +1577 -0
  422. package/src/prover/smt/solver/sat/probing.ts +170 -0
  423. package/src/prover/smt/solver/sat/sat-tactic.ts +44 -0
  424. package/src/prover/smt/solver/sat/sat2goal.ts +165 -0
  425. package/src/prover/smt/solver/sat/scc.ts +142 -0
  426. package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
  427. package/src/prover/smt/solver/sat/solver.ts +2105 -0
  428. package/src/prover/smt/solver/sat/var-queue.ts +117 -0
  429. package/src/prover/smt/solver/sat/watch-list.ts +140 -0
  430. package/src/prover/smt/solver/search-tree.ts +284 -0
  431. package/src/prover/smt/solver/seq-axioms.ts +995 -0
  432. package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
  433. package/src/prover/smt/solver/seq-derive.ts +1298 -0
  434. package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
  435. package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
  436. package/src/prover/smt/solver/seq-factory.ts +89 -0
  437. package/src/prover/smt/solver/seq-monadic.ts +730 -0
  438. package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
  439. package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -0
  440. package/src/prover/smt/solver/seq-re-util.ts +758 -0
  441. package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
  442. package/src/prover/smt/solver/seq-regex-live.ts +200 -0
  443. package/src/prover/smt/solver/seq-rewriter.ts +2404 -0
  444. package/src/prover/smt/solver/seq-skolem.ts +294 -0
  445. package/src/prover/smt/solver/seq-subset.ts +165 -0
  446. package/src/prover/smt/solver/seq-view-witness.ts +353 -0
  447. package/src/prover/smt/solver/smt-consequences.ts +297 -0
  448. package/src/prover/smt/solver/smt-kernel.ts +90 -0
  449. package/src/prover/smt/solver/smt-logics.ts +66 -0
  450. package/src/prover/smt/solver/smt-setup.ts +544 -0
  451. package/src/prover/smt/solver/smt2-printer.ts +765 -0
  452. package/src/prover/smt/solver/smtlib-parser.ts +3228 -327
  453. package/src/prover/smt/solver/smtlib-script.ts +1843 -0
  454. package/src/prover/smt/solver/solve-eqs.ts +923 -0
  455. package/src/prover/smt/solver/solver.ts +113 -22
  456. package/src/prover/smt/solver/static-features.ts +314 -0
  457. package/src/prover/smt/solver/sticky-generations.ts +0 -1
  458. package/src/prover/smt/solver/tactic.ts +2012 -0
  459. package/src/prover/smt/solver/term-enumeration.ts +205 -0
  460. package/src/prover/smt/solver/theory-array.ts +1240 -0
  461. package/src/prover/smt/solver/theory-bv.ts +1200 -0
  462. package/src/prover/smt/solver/theory-char.ts +355 -0
  463. package/src/prover/smt/solver/theory-datatype.ts +598 -0
  464. package/src/prover/smt/solver/theory-finite-set.ts +30 -0
  465. package/src/prover/smt/solver/theory-fpa.ts +389 -0
  466. package/src/prover/smt/solver/theory-lra-axioms.ts +53 -2
  467. package/src/prover/smt/solver/theory-lra-bounds.ts +31 -5
  468. package/src/prover/smt/solver/theory-lra-final-check.ts +56 -71
  469. package/src/prover/smt/solver/theory-lra-internalize.ts +89 -11
  470. package/src/prover/smt/solver/theory-lra-model.ts +20 -35
  471. package/src/prover/smt/solver/theory-lra-propagate.ts +24 -28
  472. package/src/prover/smt/solver/theory-lra-state.ts +6 -22
  473. package/src/prover/smt/solver/theory-lra.ts +188 -2
  474. package/src/prover/smt/solver/theory-pb.ts +933 -0
  475. package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
  476. package/src/prover/smt/solver/theory-recfun.ts +307 -0
  477. package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
  478. package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
  479. package/src/prover/smt/solver/theory-seq-state.ts +852 -0
  480. package/src/prover/smt/solver/theory-seq.ts +961 -0
  481. package/src/prover/smt/solver/theory.ts +189 -0
  482. package/src/prover/smt/solver/tseitin-cnf.ts +485 -0
  483. package/src/prover/smt/solver/var-subst.ts +36 -14
  484. package/src/prover/smt/table.ts +3 -2
  485. package/src/prover/smt/types.ts +146 -0
  486. package/src/prover/tlapm/cache.ts +37 -16
  487. package/src/prover/tlapm-library.ts +3208 -0
  488. package/src/prover/verdict.ts +2 -0
  489. package/src/prover/zenon/decide.ts +10 -7
  490. package/src/prover/zenon/encode.ts +0 -2
  491. package/src/prover/zenon/eqrel.ts +0 -2
  492. package/src/prover/zenon/equality-rules.ts +24 -2
  493. package/src/prover/zenon/expr.ts +21 -2
  494. package/src/prover/zenon/index-table.ts +7 -4
  495. package/src/prover/zenon/isar-case.ts +1 -3
  496. package/src/prover/zenon/isar.ts +2 -4
  497. package/src/prover/zenon/llproof.ts +0 -2
  498. package/src/prover/zenon/mltoll.ts +0 -2
  499. package/src/prover/zenon/node.ts +20 -5
  500. package/src/prover/zenon/parse.ts +6 -2
  501. package/src/prover/zenon/phrase.ts +1 -3
  502. package/src/prover/zenon/proof.ts +0 -2
  503. package/src/prover/zenon/propositional-rules.ts +0 -2
  504. package/src/prover/zenon/rules.ts +2 -3
  505. package/src/prover/zenon/search.ts +7 -5
  506. package/src/prover/zenon/tla/functions.ts +0 -2
  507. package/src/prover/zenon/tla/llproof.ts +0 -2
  508. package/src/prover/zenon/tla/records.ts +0 -2
  509. package/src/prover/zenon/tla/rewrites.ts +0 -2
  510. package/src/prover/zenon/tla/sets.ts +7 -8
  511. package/src/prover/zenon/tla/terms.ts +0 -2
  512. package/src/prover/zenon/tla/tla.ts +0 -2
  513. package/src/resolve.ts +625 -189
  514. package/src/runtime.ts +7 -1
  515. package/src/sany/builtins.ts +10 -10
  516. package/src/sany/generation.ts +2 -13
  517. package/src/sany/generator-definitions.ts +3 -1
  518. package/src/sany/generator-expressions.ts +36 -30
  519. package/src/sany/generator-proofs.ts +5 -3
  520. package/src/sany/generator.ts +2 -1
  521. package/src/sany/levels.ts +0 -2
  522. package/src/sany/lexer.ts +3 -3
  523. package/src/sany/linter.ts +0 -2
  524. package/src/sany/modules.ts +4 -2
  525. package/src/sany/nodes.ts +1 -1
  526. package/src/sany/selectors.ts +11 -6
  527. package/src/sany/xml.ts +2 -3
  528. package/src/search.ts +209 -56
  529. package/src/simulate.ts +3 -0
  530. package/src/spec-description.ts +2 -2
  531. package/src/standard-definitions.ts +4 -0
  532. package/src/state-graph.ts +0 -2
  533. package/src/subexpressions.ts +265 -94
  534. package/src/successors.ts +2 -1
  535. package/src/symmetry.ts +3 -3
  536. package/src/tableau.ts +2 -2
  537. package/src/tlc/fingerprint.ts +81 -9
  538. package/src/tlc/jar-data.ts +10 -0
  539. package/src/tlc/messages.ts +3 -3
  540. package/src/tlc/order.ts +14 -3
  541. package/src/tlc/summary.ts +29 -14
  542. package/src/tlc/tlc-operators.ts +3 -1
  543. package/src/tlc/tlcext-operators.ts +61 -16
  544. package/src/tlc/trace-spec.ts +5 -5
  545. package/src/typed-tier.ts +6541 -0
  546. package/src/typescript/types.ts +2 -2
  547. package/src/values.ts +46 -27
  548. package/src/prover/isabelle/isar/statement.ts +0 -52
  549. package/src/prover/smt/solver/z3-license.txt +0 -10
  550. package/src/prover/tlaps-module.ts +0 -510
  551. 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,7 +21,7 @@ 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";
27
26
  import { getSanyParseError } from "./sany/parse-error";
28
27
 
@@ -35,6 +34,24 @@ interface InfixOperator extends Precedence {
35
34
  isAssociative: boolean;
36
35
  }
37
36
 
37
+ interface TlapmOperand {
38
+ start: number;
39
+ end: number;
40
+ expression: Expression;
41
+ joinedBy?: string;
42
+ }
43
+
44
+ interface TlapmOperator extends Precedence {
45
+ start: number;
46
+ end: number;
47
+ fixity: "Prefix" | "Infix" | "Postfix";
48
+ isLeft: boolean;
49
+ joins?: string;
50
+ apply: (operands: TlapmOperand[]) => Expression;
51
+ }
52
+
53
+ type TlapmItem = TlapmOperand | TlapmOperator;
54
+
38
55
  const POSTFIX_PRECEDENCE = { low: 15, high: 15 };
39
56
  const FUNCTION_PRECEDENCE = { low: 16, high: 16 };
40
57
 
@@ -144,6 +161,49 @@ const INFIX_OPERATORS = new Map<string, InfixOperator>([
144
161
 
145
162
  const NEGATION_PRECEDENCE = 12;
146
163
 
164
+ // tlapm's Optable has SANY's infix precedences, groups % and \X to the left with the operators
165
+ // SANY takes as associative, and has these prefix precedences. A function application and a field
166
+ // bind above every operator.
167
+ const isTlapmLeft = (text: string, infix: InfixOperator) =>
168
+ infix.isAssociative || text === "%" || text === "\\X";
169
+
170
+ const TLAPM_PREFIX_OPERATORS = new Map<string, Precedence>([
171
+ ["~", { low: 4, high: 4 }],
172
+ ["[]", { low: 4, high: 15 }],
173
+ ["<>", { low: 4, high: 15 }],
174
+ ["ENABLED", { low: 4, high: 15 }],
175
+ ["UNCHANGED", { low: 4, high: 15 }],
176
+ ["SUBSET", { low: 8, high: 8 }],
177
+ ["UNION", { low: 8, high: 8 }],
178
+ ["DOMAIN", { low: 9, high: 9 }],
179
+ ["-", { low: 12, high: 12 }],
180
+ ["-.", { low: 12, high: 12 }],
181
+ ]);
182
+
183
+ const TLAPM_SELECTION_PRECEDENCE = { low: 17, high: 17 };
184
+
185
+ const TLAPM_ATOM_STARTS = new Set([
186
+ "(",
187
+ "[",
188
+ "{",
189
+ "<<",
190
+ "@",
191
+ "\\A",
192
+ "\\E",
193
+ "\\AA",
194
+ "\\EE",
195
+ "IF",
196
+ "CASE",
197
+ "LET",
198
+ "CHOOSE",
199
+ "LAMBDA",
200
+ "WF_",
201
+ "SF_",
202
+ ]);
203
+
204
+ // The brackets whose contents tlapm reads without committing, so a failure in them backtracks.
205
+ const TLAPM_OPEN_BRACKETS = new Set(["(", "{", "<<"]);
206
+
147
207
  const POSTFIX_OPERATORS = new Set(["^+", "^*", "^#"]);
148
208
 
149
209
  const DEFINABLE_POSTFIX_OPERATORS = new Set([...POSTFIX_OPERATORS, "'"]);
@@ -315,13 +375,30 @@ const getSpan = (range: SourceRange): Span => ({
315
375
  stop: { line: range.end.line, column: range.end.column + 1 },
316
376
  });
317
377
 
318
- const createProofError = (message: string, span: Span, exception = "Proof.Parser") =>
378
+ interface ProofErrorEnds {
379
+ printed: string;
380
+ set: string;
381
+ }
382
+
383
+ const NO_NEWLINES: ProofErrorEnds = { printed: "", set: "" };
384
+
385
+ const PRINTED_NEWLINE: ProofErrorEnds = { printed: "\n", set: "" };
386
+
387
+ const NEWLINES: ProofErrorEnds = { printed: "\n", set: "\n" };
388
+
389
+ // p_parser.ml ends some of the messages it prints, and of those it sets, with a newline.
390
+ const createProofError = (
391
+ message: string,
392
+ span: Span,
393
+ ends: ProofErrorEnds,
394
+ exception = "Proof.Parser",
395
+ ) =>
319
396
  new TlaSyntaxError(message, undefined, {
320
- reason: message,
397
+ reason: `${message}${ends.set}`,
321
398
  line: span.start.line,
322
399
  column: span.start.column,
323
400
  isEnd: false,
324
- proof: { stop: span.stop, exception },
401
+ proof: { stop: span.stop, exception, printed: `${message}${ends.printed}` },
325
402
  });
326
403
 
327
404
  const FACT_KEYWORDS = new Set([
@@ -423,9 +500,12 @@ const parse = (
423
500
  let lastOperator: Precedence | undefined;
424
501
  let precedingOperator: Precedence | undefined;
425
502
  const recursiveScopes: Set<string>[] = [];
426
- const factNames = new Set<string>();
427
- const proofScopes: Set<string>[] = [];
428
503
  const openModules: Module[] = [];
504
+ // Pco's backtracking: a failure not past a commit rewinds to its attempt's frame.
505
+ let attemptFrame: number | undefined;
506
+ let attemptCount = 0;
507
+ const restorePoints: number[] = [];
508
+ const backtracks = new WeakMap<TlaSyntaxError, number>();
429
509
 
430
510
  const isRecursiveName = (name: string) => recursiveScopes[recursiveScopes.length - 1].has(name);
431
511
 
@@ -473,15 +553,6 @@ const parse = (
473
553
  const describeToken = (token: Token) =>
474
554
  token.kind === "End" ? "end of input" : JSON.stringify(token.text);
475
555
 
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
556
  const isTlapmKeyword = (token: Token) =>
486
557
  isTlapm && (token.kind === "Keyword" || BUILTIN_CONSTANTS.has(token.text));
487
558
 
@@ -496,6 +567,7 @@ const parse = (
496
567
  };
497
568
 
498
569
  const getTlapmName = (token: Token) => {
570
+ if (token.kind === "End") return "EOF";
499
571
  if (/^-{4,}$/.test(token.text)) return "----";
500
572
  if (/^={4,}$/.test(token.text)) return "====";
501
573
  if (TLAPM_PUNCTUATION.has(token.text) || token.kind === "Number" || token.kind === "Decimal")
@@ -509,36 +581,76 @@ const parse = (
509
581
  const createError = (message: string, token: Point = peekRaw(), unexpected?: Token) => {
510
582
  const end = tokens[tokens.length - 1];
511
583
  const isEnd = token.line === end.line && token.column === end.column;
512
- return new TlaSyntaxError(
584
+ const error = new TlaSyntaxError(
513
585
  `${message} at line ${token.line}, column ${token.column}`,
514
586
  undefined,
515
587
  getFailure(message, token, isEnd, unexpected),
516
588
  );
589
+ if (attemptFrame !== undefined) backtracks.set(error, attemptFrame);
590
+ return error;
517
591
  };
518
592
 
593
+ // tlapm reports a failure after the last token it read before the outermost attempt around it.
519
594
  const getFailure = (
520
595
  message: string,
521
596
  token: Point,
522
597
  isEnd: boolean,
523
598
  unexpected: Token | undefined,
524
599
  ) => {
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 };
600
+ if (!isTlapm) return { reason: message, line: token.line, column: token.column, isEnd };
601
+ const restored = tokens[restorePoints[0] - 1];
602
+ const reason = unexpected ? `Unexpected ${getTlapmName(unexpected)}` : message;
603
+ if (restored) return { reason, line: restored.line, column: restored.endColumn + 1, isEnd };
604
+ const position = unexpected ? getPreviousEnd(unexpected) : token;
605
+ return { reason, line: position.line, column: position.column, isEnd };
537
606
  };
538
607
 
539
608
  const createUnexpected = (message: string, token: Token = peekRaw()) =>
540
609
  createError(message, token, token);
541
610
 
611
+ // Pco.attempt: a failure that backtracks to it leaves the input as it was, and gives undefined.
612
+ const attempt = <Result>(parse: () => Result): Result | undefined => {
613
+ const saved = {
614
+ cursor,
615
+ frame: attemptFrame,
616
+ restorePoints: restorePoints.length,
617
+ offsideColumns: offsideColumns.length,
618
+ recursiveScopes: recursiveScopes.length,
619
+ };
620
+ const frame = ++attemptCount;
621
+ attemptFrame = frame;
622
+ try {
623
+ const result = parse();
624
+ attemptFrame = saved.frame;
625
+ return result;
626
+ } catch (error) {
627
+ if (!(error instanceof TlaSyntaxError) || backtracks.get(error) !== frame) throw error;
628
+ cursor = saved.cursor;
629
+ attemptFrame = saved.frame;
630
+ restorePoints.length = saved.restorePoints;
631
+ offsideColumns.length = saved.offsideColumns;
632
+ recursiveScopes.length = saved.recursiveScopes;
633
+ return undefined;
634
+ }
635
+ };
636
+
637
+ // Pco.commit: a failure in parse no longer backtracks.
638
+ const commit = <Result>(parse: () => Result) => {
639
+ const frame = attemptFrame;
640
+ attemptFrame = undefined;
641
+ const result = parse();
642
+ attemptFrame = frame;
643
+ return result;
644
+ };
645
+
646
+ const withRestorePoint = <Result>(parse: () => Result) => {
647
+ restorePoints.push(cursor);
648
+ const result = parse();
649
+ restorePoints.pop();
650
+ return result;
651
+ };
652
+
653
+ // 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
654
  const isFieldName = (token: Token) =>
543
655
  (token.kind === "Identifier" ||
544
656
  token.kind === "Keyword" ||
@@ -552,7 +664,7 @@ const parse = (
552
664
 
553
665
  const advance = () => {
554
666
  const token = peek();
555
- if (token.kind === "End") throw createError("Unexpected end of expression");
667
+ if (token.kind === "End") throw createUnexpected("Unexpected end of expression");
556
668
  cursor++;
557
669
  return token;
558
670
  };
@@ -622,13 +734,13 @@ const parse = (
622
734
  return items;
623
735
  };
624
736
 
625
- const isBoundAhead = () => {
626
- if (isAt("<<")) {
627
- let offset = 1;
737
+ const isBoundAhead = (start = 0) => {
738
+ if (isAt("<<", start)) {
739
+ let offset = start + 1;
628
740
  while (peek(offset).kind === "Identifier" || isAt(",", offset)) offset++;
629
741
  return isAt(">>", offset) && isAt("\\in", offset + 1);
630
742
  }
631
- let offset = 0;
743
+ let offset = start;
632
744
  while (peek(offset).kind === "Identifier") {
633
745
  if (isAt("\\in", offset + 1)) return true;
634
746
  if (!isAt(",", offset + 1)) return false;
@@ -655,13 +767,21 @@ const parse = (
655
767
  return { kind: "Tuple", names: names.names, ranges: names.ranges };
656
768
  };
657
769
 
658
- const parseBounds = () =>
659
- parseSeparated(() => {
770
+ // tlapm's func_boundeds reads another bound only where names and \in follow the comma.
771
+ const parseBounds = () => {
772
+ const parseBound = () => {
660
773
  const patterns = parseSeparated(parsePattern);
661
774
  expect("\\in");
662
- const set = parseExpression();
775
+ const set = commit(parseExpression);
663
776
  return patterns.map((pattern) => ({ pattern, set }));
664
- }).flat();
777
+ };
778
+ const bounds = [parseBound()];
779
+ while (isAt(",") && (!isTlapm || isBoundAhead(1))) {
780
+ advance();
781
+ bounds.push(parseBound());
782
+ }
783
+ return bounds.flat();
784
+ };
665
785
 
666
786
  const parseSubscript = (): { subscript: Expression; lastArgs: Expression[] } => {
667
787
  const token = peek();
@@ -823,7 +943,11 @@ const parse = (
823
943
  start,
824
944
  );
825
945
  }
826
- return parseExpression();
946
+ if (!isTlapm) return parseExpression();
947
+ // tlapm's oparg reads an operator where an expression doesn't start, and fails otherwise.
948
+ const argument = attempt(parseExpression);
949
+ if (argument) return argument;
950
+ throw createUnexpected(`Unexpected ${describeToken(peek())}`);
827
951
  };
828
952
 
829
953
  let lastArgumentsRange: SourceRange | undefined;
@@ -842,14 +966,19 @@ const parse = (
842
966
  const bullet = advance();
843
967
  offsideColumns.push(bullet.column);
844
968
  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
- }
969
+ const parseItems = () => {
970
+ while (
971
+ isBullet(peekRaw()) &&
972
+ peekRaw().text === bullet.text &&
973
+ peekRaw().column === bullet.column
974
+ ) {
975
+ cursor++;
976
+ operands.push(parseExpression());
977
+ }
978
+ };
979
+ // bulleted_list: a first item that fails leaves expr_or_op's other readings to fail after it.
980
+ if (isTlapm) commit(parseItems);
981
+ else parseItems();
853
982
  offsideColumns.pop();
854
983
  return {
855
984
  kind: bullet.text === "/\\" ? "And" : "Or",
@@ -940,7 +1069,7 @@ const parse = (
940
1069
  const element = withRange(parsePrefix(), start);
941
1070
  const location = getLocation(advance());
942
1071
  return withRange(
943
- { kind: "Apply", operator: "\\in", args: [element, parseExpression()], location },
1072
+ { kind: "Apply", operator: "\\in", args: [element, commit(parseExpression)], location },
944
1073
  start,
945
1074
  );
946
1075
  };
@@ -953,9 +1082,9 @@ const parse = (
953
1082
  const checkpoint = cursor;
954
1083
  const pattern = parsePattern();
955
1084
  expect("\\in");
956
- const set = parseExpression();
1085
+ const set = commit(parseExpression);
957
1086
  if (accept(":")) {
958
- const predicate = parseExpression();
1087
+ const predicate = commit(parseExpression);
959
1088
  expect("}");
960
1089
  return { kind: "SetFilter", bound: { pattern, set }, predicate, location };
961
1090
  }
@@ -985,7 +1114,7 @@ const parse = (
985
1114
  return {
986
1115
  kind: "AngleAction",
987
1116
  action: elements[0],
988
- subscript: parseSubscript().subscript,
1117
+ subscript: commit(parseSubscript).subscript,
989
1118
  location,
990
1119
  };
991
1120
  }
@@ -1070,6 +1199,55 @@ const parse = (
1070
1199
  return { kind: "Name", name: token.text, args: isAt("(") ? parseArguments() : [] };
1071
1200
  };
1072
1201
 
1202
+ const parseSelections = (
1203
+ name: string,
1204
+ args: Expression[],
1205
+ argumentsRange: SourceRange | undefined,
1206
+ start: number,
1207
+ location: SourceLocation,
1208
+ ): Expression => {
1209
+ const selectors: Selector[] = [{ kind: "Name", name, args }];
1210
+ const selectorRanges = [getRange(start, start)];
1211
+ const argumentRanges = [argumentsRange];
1212
+ while (isSelectorAhead()) {
1213
+ advance();
1214
+ const selectorStart = cursor;
1215
+ lastArgumentsRange = undefined;
1216
+ const selector = parseSelector();
1217
+ selectorRanges.push(
1218
+ selector.kind === "Bound"
1219
+ ? getRange(selectorStart)
1220
+ : getRange(selectorStart, selectorStart),
1221
+ );
1222
+ selectors.push(selector);
1223
+ argumentRanges.push(lastArgumentsRange);
1224
+ }
1225
+ const names = selectors.flatMap((selector) =>
1226
+ selector.kind === "Name" ? [selector.name] : [],
1227
+ );
1228
+ const operator = names.join("!");
1229
+ const qualifiedArgs = selectors.flatMap((selector) =>
1230
+ "args" in selector ? selector.args : [],
1231
+ );
1232
+ const argumentCounts = selectors.map((selector) =>
1233
+ "args" in selector ? selector.args.length : 0,
1234
+ );
1235
+ return names.length < selectors.length
1236
+ ? { kind: "Subexpression", selectors, selectorRanges, argumentRanges, location }
1237
+ : qualifiedArgs.length === 0
1238
+ ? { kind: "Identifier", name: operator, selectorRanges, location }
1239
+ : {
1240
+ kind: "Apply",
1241
+ operator,
1242
+ args: qualifiedArgs,
1243
+ ...(argumentCounts.slice(0, -1).some((count) => count > 0) && { argumentCounts }),
1244
+ argumentsRange: argumentRanges.at(-1) ?? getRange(start),
1245
+ selectorRanges,
1246
+ argumentRanges,
1247
+ location,
1248
+ };
1249
+ };
1250
+
1073
1251
  const parsePrimary = (preceding?: Precedence): Expression => {
1074
1252
  const start = cursor;
1075
1253
  const token = advance();
@@ -1079,10 +1257,8 @@ const parse = (
1079
1257
  expect(":");
1080
1258
  return { kind: "Lambda", params, body: parseExpression(), location };
1081
1259
  }
1082
- if (token.kind === "Number") {
1083
- if (isTlapm && /^\\[BOH]/.test(token.text)) throw createError("incomplete expression", token);
1260
+ if (token.kind === "Number")
1084
1261
  return { kind: "Number", value: getNumeralValue(token.text), text: token.text, location };
1085
- }
1086
1262
  if (token.kind === "Decimal") return { kind: "Decimal", text: token.text, location };
1087
1263
  if (token.kind === "String") return { kind: "String", value: token.text, location };
1088
1264
  const isStep = token.kind === "Step" && isStepReference(token);
@@ -1123,56 +1299,45 @@ const parse = (
1123
1299
  if (name === "@" && !hasArguments && !isSelectorAhead())
1124
1300
  return { kind: "ExceptAt", location };
1125
1301
  const args = hasArguments ? parseArguments() : [];
1126
- const argumentRanges = [hasArguments ? lastArgumentsRange : undefined];
1127
1302
  if (!isSelectorAhead()) {
1128
1303
  return hasArguments
1129
1304
  ? { kind: "Apply", operator: name, args, argumentsRange: lastArgumentsRange, location }
1130
1305
  : { kind: "Identifier", name, location };
1131
1306
  }
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,
1307
+ return parseSelections(
1308
+ name,
1309
+ args,
1310
+ hasArguments ? lastArgumentsRange : undefined,
1311
+ start,
1312
+ location,
1150
1313
  );
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
1314
  }
1167
- if (token.kind === "Operator" && isOperatorName(token.text) && isAt("(")) {
1315
+ const isOperatorNamed =
1316
+ token.kind === "Operator" && (isOperatorName(token.text) || (token.text === "'" && !isTlapm));
1317
+ if (isOperatorNamed && isAt("(")) {
1168
1318
  const args = parseArguments();
1319
+ if (!isTlapm && isSelectorAhead()) {
1320
+ return parseSelections(token.text, args, lastArgumentsRange, start, location);
1321
+ }
1169
1322
  // 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 };
1323
+ if (mode === "tlc" && token.text === "\\X" && args.length === 2) {
1324
+ return { kind: "Product", factors: args, location };
1325
+ }
1326
+ return token.text === "'" && args.length === 1
1327
+ ? { kind: "Prime", expression: args[0], location }
1328
+ : {
1329
+ kind: "Apply",
1330
+ operator: token.text,
1331
+ spelling: token.spelling,
1332
+ args,
1333
+ argumentsRange: lastArgumentsRange,
1334
+ location,
1335
+ };
1173
1336
  }
1174
- if (token.kind === "Operator" && isOperatorName(token.text) && !isTlapm) {
1175
- return { kind: "Identifier", name: token.text, spelling: token.spelling, location };
1337
+ if (isOperatorNamed && !isTlapm) {
1338
+ return isSelectorAhead()
1339
+ ? parseSelections(token.text, [], undefined, start, location)
1340
+ : { kind: "Identifier", name: token.text, spelling: token.spelling, location };
1176
1341
  }
1177
1342
  switch (token.text) {
1178
1343
  case "(": {
@@ -1205,12 +1370,12 @@ const parse = (
1205
1370
  case "LET": {
1206
1371
  const definitions: Definition[] = [];
1207
1372
  const instances: Instance[] = [];
1373
+ const recursive: Declaration[] = [];
1208
1374
  recursiveScopes.push(new Set());
1209
1375
  while (!accept("IN")) {
1210
- if (isTlapm && isAt("RECURSIVE"))
1211
- throw createError("Unexpected keyword RECURSIVE", getDefinitionEnd(peekRaw()));
1376
+ if (isTlapm && isAt("RECURSIVE")) throw createUnexpected("Unexpected keyword RECURSIVE");
1212
1377
  if (accept("RECURSIVE")) {
1213
- declareRecursive();
1378
+ recursive.push(...declareRecursive());
1214
1379
  continue;
1215
1380
  }
1216
1381
  const unit = parseDefinition(!isTlapm && accept("LOCAL"));
@@ -1218,10 +1383,14 @@ const parse = (
1218
1383
  else definitions.push(unit);
1219
1384
  }
1220
1385
  recursiveScopes.pop();
1221
- const body = parseExpression();
1222
- return instances.length === 0
1223
- ? { kind: "Let", definitions, body, location }
1224
- : { kind: "Let", definitions, instances, body, location };
1386
+ return {
1387
+ kind: "Let",
1388
+ definitions,
1389
+ ...(instances.length > 0 && { instances }),
1390
+ ...(recursive.length > 0 && { recursive }),
1391
+ body: parseExpression(),
1392
+ location,
1393
+ };
1225
1394
  }
1226
1395
  case "CHOOSE": {
1227
1396
  const pattern = parsePattern();
@@ -1254,14 +1423,12 @@ const parse = (
1254
1423
 
1255
1424
  const parsePrefixOperand = (operator: Token, low: number, high: number) => {
1256
1425
  lastOperator = precedingOperator = { low, high };
1257
- const operand = parseExpression(
1258
- isTlapm ? Math.min(high + 1, POSTFIX_PRECEDENCE.low) : high + 1,
1259
- );
1426
+ const operand = parseExpression(high + 1);
1260
1427
  const next = peek();
1261
1428
  const nextHigh = DEFINABLE_POSTFIX_OPERATORS.has(next.text)
1262
1429
  ? POSTFIX_PRECEDENCE.high
1263
1430
  : INFIX_OPERATORS.get(next.text)?.high;
1264
- if (!isTlapm && next.kind === "Operator" && nextHigh !== undefined && nextHigh >= low) {
1431
+ if (next.kind === "Operator" && nextHigh !== undefined && nextHigh >= low) {
1265
1432
  throw createError(`Precedence conflict between ${operator.text} and ${next.text}`, next);
1266
1433
  }
1267
1434
  return operand;
@@ -1275,26 +1442,6 @@ const parse = (
1275
1442
  if (token.kind === "Operator" && isBullet(token)) {
1276
1443
  return parseJunctionList();
1277
1444
  }
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
1445
  if (token.kind === "Operator" || token.kind === "Keyword") {
1299
1446
  switch (token.text) {
1300
1447
  case "~":
@@ -1306,8 +1453,6 @@ const parse = (
1306
1453
  location,
1307
1454
  };
1308
1455
  case "-":
1309
- case "-.":
1310
- if (token.text === "-." && !isTlapm) break;
1311
1456
  advance();
1312
1457
  return {
1313
1458
  kind: "Apply",
@@ -1328,7 +1473,7 @@ const parse = (
1328
1473
  return {
1329
1474
  kind: "Apply",
1330
1475
  operator: token.text,
1331
- args: [isTlapm ? parseExpression(9) : parsePrefixOperand(token, 10, 13)],
1476
+ args: [parsePrefixOperand(token, 10, 13)],
1332
1477
  location,
1333
1478
  };
1334
1479
  }
@@ -1336,7 +1481,57 @@ const parse = (
1336
1481
  return parsePrimary(preceding);
1337
1482
  };
1338
1483
 
1339
- const parseExpression = (minimumPrecedence = 0): Expression => {
1484
+ const getInfixApplication = (
1485
+ token: Token,
1486
+ left: Expression,
1487
+ right: Expression,
1488
+ isChained: boolean,
1489
+ prefixEnd: Point,
1490
+ ): Expression => {
1491
+ const location = getLocation(token);
1492
+ if (token.text === "/\\" || token.text === "\\/") {
1493
+ const kind = token.text === "/\\" ? "And" : "Or";
1494
+ return left.kind === kind && isChained
1495
+ ? {
1496
+ ...left,
1497
+ operands: [...left.operands, right],
1498
+ prefixEnds: [...(left.prefixEnds ?? []), prefixEnd],
1499
+ }
1500
+ : { kind, operands: [left, right], prefixEnds: [prefixEnd], location };
1501
+ }
1502
+ if (token.text === "\\X") {
1503
+ return left.kind === "Product" && isChained
1504
+ ? { ...left, factors: [...left.factors, right] }
1505
+ : { kind: "Product", factors: [left, right], location };
1506
+ }
1507
+ return {
1508
+ kind: "Apply",
1509
+ operator: token.text,
1510
+ spelling: token.spelling,
1511
+ args: [left, right],
1512
+ location,
1513
+ };
1514
+ };
1515
+
1516
+ const getPostfixApplication = (token: Token, operand: Expression): Expression =>
1517
+ token.text === "'"
1518
+ ? { kind: "Prime", expression: operand, location: getLocation(token) }
1519
+ : {
1520
+ kind: "Apply",
1521
+ operator: token.text,
1522
+ spelling: token.spelling,
1523
+ args: [operand],
1524
+ location: getLocation(token),
1525
+ };
1526
+
1527
+ const parseFunctionArguments = () => {
1528
+ advance();
1529
+ const args = withBracketLayout(() => parseSeparated(() => parseExpression()));
1530
+ withBracketLayout(() => expect("]"));
1531
+ return args;
1532
+ };
1533
+
1534
+ const parseSanyExpression = (minimumPrecedence: number): Expression => {
1340
1535
  const start = cursor;
1341
1536
  const prefix = parsePrefix();
1342
1537
  let left = prefix.location.range ? prefix : withRange(prefix, start);
@@ -1345,31 +1540,14 @@ const parse = (
1345
1540
  const token = peek();
1346
1541
  if (token.kind !== "Operator") break;
1347
1542
  const location = getLocation(token);
1348
- if (token.text === "'" && minimumPrecedence <= 15) {
1543
+ if (DEFINABLE_POSTFIX_OPERATORS.has(token.text) && minimumPrecedence <= 15) {
1349
1544
  advance();
1350
1545
  lastOperator = POSTFIX_PRECEDENCE;
1351
- left = withRange({ kind: "Prime", expression: left, location }, start);
1352
- continue;
1353
- }
1354
- if (POSTFIX_OPERATORS.has(token.text) && minimumPrecedence <= 15) {
1355
- advance();
1356
- lastOperator = POSTFIX_PRECEDENCE;
1357
- left = withRange(
1358
- {
1359
- kind: "Apply",
1360
- operator: token.text,
1361
- spelling: token.spelling,
1362
- args: [left],
1363
- location,
1364
- },
1365
- start,
1366
- );
1546
+ left = withRange(getPostfixApplication(token, left), start);
1367
1547
  continue;
1368
1548
  }
1369
1549
  if (token.text === "[") {
1370
- advance();
1371
- const args = withBracketLayout(() => parseSeparated(() => parseExpression()));
1372
- withBracketLayout(() => expect("]"));
1550
+ const args = parseFunctionArguments();
1373
1551
  lastOperator = FUNCTION_PRECEDENCE;
1374
1552
  left = withRange({ kind: "FunctionApplication", function: left, args, location }, start);
1375
1553
  continue;
@@ -1393,42 +1571,260 @@ const parse = (
1393
1571
  }
1394
1572
  }
1395
1573
  advance();
1396
- if (!isTlapm && infix.low > NEGATION_PRECEDENCE && isAt("-")) {
1574
+ if (infix.low > NEGATION_PRECEDENCE && isAt("-")) {
1397
1575
  throw createError(`Precedence conflict between ${token.text} and -`, peek());
1398
1576
  }
1399
1577
  lastOperator = precedingOperator = infix;
1400
1578
  const right = parseExpression(infix.high + 1);
1401
- if (token.text === "/\\" || token.text === "\\/") {
1402
- const kind = token.text === "/\\" ? "And" : "Or";
1403
- const prefixEnds = [getRange(start).end];
1404
- left =
1405
- left.kind === kind && previous?.text === token.text
1406
- ? {
1407
- ...left,
1408
- operands: [...left.operands, right],
1409
- prefixEnds: [...(left.prefixEnds ?? []), ...prefixEnds],
1410
- }
1411
- : { kind, operands: [left, right], prefixEnds, location };
1412
- } else if (token.text === "\\X") {
1413
- left =
1414
- left.kind === "Product" && previous?.text === "\\X"
1415
- ? { ...left, factors: [...left.factors, right] }
1416
- : { kind: "Product", factors: [left, right], location };
1417
- } else {
1418
- left = {
1419
- kind: "Apply",
1420
- operator: token.text,
1421
- spelling: token.spelling,
1422
- args: [left, right],
1579
+ const isChained = previous?.text === token.text;
1580
+ left = withRange(
1581
+ getInfixApplication(token, left, right, isChained, getRange(start).end),
1582
+ start,
1583
+ );
1584
+ previous = { ...infix, text: token.text };
1585
+ }
1586
+ return left;
1587
+ };
1588
+
1589
+ const isTlapmAtomStart = (token: Token) =>
1590
+ token.kind === "Number" ||
1591
+ token.kind === "Decimal" ||
1592
+ token.kind === "String" ||
1593
+ token.kind === "Identifier" ||
1594
+ (token.kind === "Step" && isStepReference(token) && /^<\d/.test(token.text)) ||
1595
+ ((token.kind === "Operator" || token.kind === "Keyword") && TLAPM_ATOM_STARTS.has(token.text));
1596
+
1597
+ const getTlapmOperand = (expression: Expression, start: number): TlapmOperand => ({
1598
+ start,
1599
+ end: cursor - 1,
1600
+ expression: expression.location.range ? expression : withRange(expression, start),
1601
+ });
1602
+
1603
+ const getTlapmOperator = (
1604
+ start: number,
1605
+ fixity: TlapmOperator["fixity"],
1606
+ precedence: Precedence,
1607
+ apply: TlapmOperator["apply"],
1608
+ ): TlapmOperator => ({
1609
+ ...precedence,
1610
+ start,
1611
+ end: cursor - 1,
1612
+ fixity,
1613
+ isLeft: false,
1614
+ apply,
1615
+ });
1616
+
1617
+ // expr_or_op's non_test: a postfix operator before an expression in parentheses is an atom.
1618
+ const parseTlapmNonfixPostfix = (token: Token) =>
1619
+ token.kind === "Operator" && DEFINABLE_POSTFIX_OPERATORS.has(token.text) && isAt("(", 1)
1620
+ ? attempt(() =>
1621
+ withBracketLayout(() => {
1622
+ advance();
1623
+ advance();
1624
+ const operand = parseExpression();
1625
+ const end = cursor - 1;
1626
+ expect(")");
1627
+ return { end, expression: getPostfixApplication(token, operand) };
1628
+ }),
1629
+ )
1630
+ : undefined;
1631
+
1632
+ // A comma directly inside the parentheses after the operator, without which non_test's
1633
+ // attempt at `(e, f)` fails. A selector's << or >> isn't a bracket.
1634
+ const hasNonfixComma = () => {
1635
+ let depth = 0;
1636
+ for (let index = cursor + 1; index < tokens.length; index++) {
1637
+ const token = tokens[index];
1638
+ if (token.kind !== "Operator") continue;
1639
+ if (depth === 1 && token.text === ",") return true;
1640
+ if (tokens[index - 1].text === "!") continue;
1641
+ if (OPENING_BRACKETS.has(token.text)) depth++;
1642
+ if (CLOSING_BRACKETS.has(token.text) && --depth === 0) return false;
1643
+ }
1644
+ return false;
1645
+ };
1646
+
1647
+ // expr_or_op's non_test: an infix operator before two expressions in parentheses is an atom.
1648
+ const parseTlapmNonfixInfix = (token: Token) =>
1649
+ isAt("(", 1) && hasNonfixComma()
1650
+ ? attempt(() =>
1651
+ withBracketLayout((): Expression => {
1652
+ advance();
1653
+ advance();
1654
+ const left = parseExpression();
1655
+ expect(",");
1656
+ const right = parseExpression();
1657
+ expect(")");
1658
+ return {
1659
+ kind: "Apply",
1660
+ operator: token.text,
1661
+ args: [left, right],
1662
+ location: getLocation(token),
1663
+ };
1664
+ }),
1665
+ )
1666
+ : undefined;
1667
+
1668
+ const parseTlapmItem = (isStart: boolean): TlapmItem | undefined => {
1669
+ const start = cursor;
1670
+ const token = peek();
1671
+ const location = getLocation(token);
1672
+ const isOperator = token.kind === "Operator" || token.kind === "Keyword";
1673
+ const infix = isOperator ? INFIX_OPERATORS.get(token.text) : undefined;
1674
+ if (!isStart) {
1675
+ if (isAt("[")) {
1676
+ const args = parseFunctionArguments();
1677
+ return getTlapmOperator(start, "Postfix", TLAPM_SELECTION_PRECEDENCE, (operands) => ({
1678
+ kind: "FunctionApplication",
1679
+ function: operands[0].expression,
1680
+ args,
1423
1681
  location,
1682
+ }));
1683
+ }
1684
+ if (isAt(".") && isFieldName(peek(1))) {
1685
+ advance();
1686
+ const field = advance().text;
1687
+ return getTlapmOperator(start, "Postfix", TLAPM_SELECTION_PRECEDENCE, (operands) => ({
1688
+ kind: "FieldAccess",
1689
+ record: operands[0].expression,
1690
+ field,
1691
+ location,
1692
+ }));
1693
+ }
1694
+ if (infix) {
1695
+ // Pco.resolve has no operator to put before that atom, so the expression ends here.
1696
+ if (parseTlapmNonfixInfix(token)) {
1697
+ cursor = start;
1698
+ return undefined;
1699
+ }
1700
+ advance();
1701
+ return {
1702
+ ...getTlapmOperator(start, "Infix", infix, (operands) =>
1703
+ getInfixApplication(
1704
+ token,
1705
+ operands[0].expression,
1706
+ operands[1].expression,
1707
+ operands[0].joinedBy === token.text,
1708
+ getRange(operands[0].start, operands[1].end).end,
1709
+ ),
1710
+ ),
1711
+ isLeft: isTlapmLeft(token.text, infix),
1712
+ joins: token.text,
1424
1713
  };
1425
1714
  }
1426
- left = withRange(left, start);
1427
- previous = { ...infix, text: token.text };
1715
+ if (token.kind !== "Operator" || !DEFINABLE_POSTFIX_OPERATORS.has(token.text))
1716
+ return undefined;
1717
+ // Pco.resolve has no operator to put before that atom, so the expression ends here.
1718
+ if (parseTlapmNonfixPostfix(token)) {
1719
+ cursor = start;
1720
+ return undefined;
1721
+ }
1722
+ advance();
1723
+ return getTlapmOperator(start, "Postfix", POSTFIX_PRECEDENCE, (operands) =>
1724
+ getPostfixApplication(token, operands[0].expression),
1725
+ );
1428
1726
  }
1429
- return left;
1727
+ if (token.kind === "Operator" && isBullet(token))
1728
+ return getTlapmOperand(parseJunctionList(), start);
1729
+ const nonfix = infix ? parseTlapmNonfixInfix(token) : undefined;
1730
+ if (nonfix) return getTlapmOperand(nonfix, start);
1731
+ const nonfixPostfix = parseTlapmNonfixPostfix(token);
1732
+ if (nonfixPostfix) {
1733
+ nonfixPostfix.expression.location.range = getRange(start, nonfixPostfix.end);
1734
+ return { start, end: nonfixPostfix.end, expression: nonfixPostfix.expression };
1735
+ }
1736
+ const prefix = isOperator ? TLAPM_PREFIX_OPERATORS.get(token.text) : undefined;
1737
+ if (prefix) {
1738
+ advance();
1739
+ return getTlapmOperator(start, "Prefix", prefix, (operands) =>
1740
+ getOperatorApplication(
1741
+ token.text === "-" ? "-." : token.text,
1742
+ operands[0].expression,
1743
+ location,
1744
+ ),
1745
+ );
1746
+ }
1747
+ if (!isTlapmAtomStart(token)) return undefined;
1748
+ const isTransparent = token.kind === "Operator" && TLAPM_OPEN_BRACKETS.has(token.text);
1749
+ return getTlapmOperand(isTransparent ? parsePrimary() : commit(parsePrimary), start);
1750
+ };
1751
+
1752
+ const isTlapmOperator = (item: TlapmItem | undefined): item is TlapmOperator =>
1753
+ item !== undefined && "fixity" in item;
1754
+
1755
+ const isTlapmOperand = (item: TlapmItem | undefined): item is TlapmOperand =>
1756
+ item !== undefined && !("fixity" in item);
1757
+
1758
+ const applyTlapmOperator = (operator: TlapmOperator, operands: TlapmOperand[]) => {
1759
+ const start = Math.min(operator.start, operands[0].start);
1760
+ const end = Math.max(operator.end, operands[operands.length - 1].end);
1761
+ const expression = operator.apply(operands);
1762
+ expression.location.range = getRange(start, end);
1763
+ return { start, end, expression, joinedBy: operator.joins };
1430
1764
  };
1431
1765
 
1766
+ const reduceTlapmItems = (stack: TlapmItem[]) => {
1767
+ const right = stack.pop();
1768
+ const operator = stack.pop();
1769
+ if (!isTlapmOperand(right) || !isTlapmOperator(operator)) {
1770
+ throw createError("incomplete expression");
1771
+ }
1772
+ const left = operator.fixity === "Infix" ? stack.pop() : undefined;
1773
+ stack.push(applyTlapmOperator(operator, isTlapmOperand(left) ? [left, right] : [right]));
1774
+ };
1775
+
1776
+ const getPreviousOperator = (stack: TlapmItem[]) => {
1777
+ const previous = stack[stack.length - 2];
1778
+ return isTlapmOperator(previous) ? previous : undefined;
1779
+ };
1780
+
1781
+ const isBelow = (left: Precedence, right: Precedence | undefined) =>
1782
+ right !== undefined && left.high < right.low;
1783
+
1784
+ // Port of Pco.resolve. A failure after the first item backtracks no further than its attempt.
1785
+ const parseTlapmExpression = (): Expression =>
1786
+ withRestorePoint(() => {
1787
+ const first = attempt(() => parseTlapmItem(true));
1788
+ if (first === undefined) {
1789
+ const token = peekRaw();
1790
+ throw token.kind === "End"
1791
+ ? createUnexpected("Unexpected end of expression", token)
1792
+ : createError(`required expressions(s) missing before '${getTlapmName(token)}'`, token);
1793
+ }
1794
+ return commit(() => {
1795
+ const stack = [first];
1796
+ while (true) {
1797
+ const item = attempt(() => parseTlapmItem(isTlapmOperator(stack[stack.length - 1])));
1798
+ if (item === undefined) break;
1799
+ if (isTlapmOperand(item) || item.fixity === "Prefix") {
1800
+ stack.push(item);
1801
+ continue;
1802
+ }
1803
+ while (isBelow(item, getPreviousOperator(stack))) reduceTlapmItems(stack);
1804
+ const operand = stack[stack.length - 1];
1805
+ if (item.fixity === "Postfix" && isTlapmOperand(operand)) {
1806
+ stack.splice(-1, 1, applyTlapmOperator(item, [operand]));
1807
+ continue;
1808
+ }
1809
+ const previous = getPreviousOperator(stack);
1810
+ const isLeftChain =
1811
+ previous?.fixity === "Infix" &&
1812
+ previous.isLeft &&
1813
+ item.isLeft &&
1814
+ !isBelow(previous, item);
1815
+ if (isLeftChain) reduceTlapmItems(stack);
1816
+ stack.push(item);
1817
+ }
1818
+ while (stack.length > 1) reduceTlapmItems(stack);
1819
+ const result = stack[0];
1820
+ if (!isTlapmOperand(result)) throw createError("incomplete expression");
1821
+ return result.expression;
1822
+ });
1823
+ });
1824
+
1825
+ const parseExpression = (minimumPrecedence = 0) =>
1826
+ isTlapm ? parseTlapmExpression() : parseSanyExpression(minimumPrecedence);
1827
+
1432
1828
  const parseParams = () => {
1433
1829
  if (!accept("(")) return [];
1434
1830
  const params = parseDeclarations();
@@ -1673,23 +2069,6 @@ const parse = (
1673
2069
  return isFirst ? level > outer : proofLevels[top] === level;
1674
2070
  };
1675
2071
 
1676
- const isDeclared = (name: string) =>
1677
- !factNames.has(name) &&
1678
- openModules.some(
1679
- (module) =>
1680
- module.constants.some((constant) => constant.name === name) ||
1681
- module.variables.some((variable) => variable.name === name) ||
1682
- module.definitions.some((definition) => definition.name === name),
1683
- );
1684
-
1685
- const isHideFact = (fact: Fact) => {
1686
- if (fact.kind === "ModuleFact" || fact.kind === "Subexpression") return true;
1687
- if (fact.kind === "Apply") return fact.operator.includes("!");
1688
- if (fact.kind !== "Identifier") return false;
1689
- if (fact.name.startsWith("<") || fact.name.includes("!")) return true;
1690
- return !BUILTIN_CONSTANTS.has(fact.name) && !isDeclared(fact.name);
1691
- };
1692
-
1693
2072
  const isFactAhead = () => {
1694
2073
  const token = peek();
1695
2074
  if (token.kind === "Step") return isStepReference(token);
@@ -1726,23 +2105,6 @@ const parse = (
1726
2105
  );
1727
2106
  };
1728
2107
 
1729
- const declareProofSymbol = (name: string) => proofScopes[proofScopes.length - 1]?.add(name);
1730
-
1731
- const withProofScope = <Result>(parse: () => Result) => {
1732
- proofScopes.push(new Set());
1733
- const result = parse();
1734
- proofScopes.pop();
1735
- return result;
1736
- };
1737
-
1738
- const isDeclaredSymbol = (name: string) =>
1739
- proofScopes.some((scope) => scope.has(name)) ||
1740
- openModules.some(
1741
- (module) =>
1742
- module.constants.some((constant) => constant.name === name) ||
1743
- module.variables.some((variable) => variable.name === name),
1744
- );
1745
-
1746
2108
  const parseDefinable = (): Fact => {
1747
2109
  const start = cursor;
1748
2110
  const token = peek();
@@ -1764,21 +2126,28 @@ const parse = (
1764
2126
  );
1765
2127
  };
1766
2128
 
1767
- const parseDefs = () => {
1768
- if (isTlapm) return parseSeparated(parseDefinable);
1769
- const defs = parseSeparated(parseFact);
1770
- const invalid =
1771
- mode === "tlc"
1772
- ? defs.find((def) => def.kind === "Identifier" && isDeclaredSymbol(def.name))
1773
- : undefined;
1774
- if (invalid) {
1775
- throw createError("DEF clause entry should describe a defined operator", invalid.location);
1776
- }
1777
- return defs;
2129
+ const parseDefs = () => parseSeparated(isTlapm ? parseDefinable : parseFact);
2130
+
2131
+ // tlapm's usebody reads facts while an expression starts after the comma.
2132
+ const parseTlapmFacts = (): Fact[] => {
2133
+ const first = attempt(parseExpression);
2134
+ if (!first) return [];
2135
+ const facts = [first];
2136
+ withRestorePoint(() => {
2137
+ while (isAt(",")) {
2138
+ const fact = attempt(() => {
2139
+ advance();
2140
+ return parseExpression();
2141
+ });
2142
+ if (!fact) return;
2143
+ facts.push(fact);
2144
+ }
2145
+ });
2146
+ return facts;
1778
2147
  };
1779
2148
 
1780
2149
  const parseFacts = () => {
1781
- const facts = isFactAhead() ? parseSeparated(parseFact) : [];
2150
+ const facts = isTlapm ? parseTlapmFacts() : isFactAhead() ? parseSeparated(parseFact) : [];
1782
2151
  const isDef = accept("DEF") || accept("DEFS");
1783
2152
  if (isTlapm && facts.length === 0 && !isDef) throw createUnexpected("Expected a fact");
1784
2153
  return { facts, defs: isDef ? parseDefs() : [] };
@@ -1789,25 +2158,16 @@ const parse = (
1789
2158
  const keyword = advance();
1790
2159
  const isOnly = keyword.text === "USE" && accept("ONLY");
1791
2160
  const keywordRange = getRange(start);
1792
- const use: UseOrHide = {
1793
- kind: keyword.text === "USE" ? "Use" : "Hide",
1794
- isOnly,
1795
- ...parseFacts(),
1796
- keyword: keywordRange,
1797
- location: getLocation(keyword),
1798
- };
1799
- const invalid =
1800
- use.kind === "Hide" && mode === "tlc" ? use.facts.filter((fact) => !isHideFact(fact)) : [];
1801
- if (invalid.length > 0) {
1802
- throw createSanyError(
1803
- invalid.map((fact) => ({
1804
- location: formatRange(fact.location.range ?? getRange(start)),
1805
- message:
1806
- "The only expression allowed as a fact in a HIDE is \nthe name of a theorem, assumption, or step.",
1807
- })),
1808
- );
1809
- }
1810
- return withRange(use, start);
2161
+ return withRange(
2162
+ {
2163
+ kind: keyword.text === "USE" ? "Use" : "Hide",
2164
+ isOnly,
2165
+ ...parseFacts(),
2166
+ keyword: keywordRange,
2167
+ location: getLocation(keyword),
2168
+ },
2169
+ start,
2170
+ );
1811
2171
  };
1812
2172
 
1813
2173
  const parseNewSymbol = (): NewSymbol => {
@@ -1823,7 +2183,6 @@ const parse = (
1823
2183
  if (level !== undefined) advance();
1824
2184
  if (level === "Variable") {
1825
2185
  const named = expectName();
1826
- declareProofSymbol(named.name);
1827
2186
  return withRange(
1828
2187
  {
1829
2188
  kind: "NewSymbol",
@@ -1838,7 +2197,6 @@ const parse = (
1838
2197
  );
1839
2198
  }
1840
2199
  const declaration = parseDeclaration();
1841
- declareProofSymbol(declaration.name);
1842
2200
  const isBounded = (level ?? "Constant") === "Constant" && isAt("\\in");
1843
2201
  if (isBounded && declaration.arity > 0) {
1844
2202
  throw createError("declared symbol with arguments before \\in");
@@ -1858,23 +2216,50 @@ const parse = (
1858
2216
  );
1859
2217
  };
1860
2218
 
2219
+ const parseHypothesis = () => {
2220
+ if (peek().kind === "Identifier" && isAt("::", 1) && isAt("ASSUME", 2)) {
2221
+ advance();
2222
+ advance();
2223
+ }
2224
+ if (isAt("ASSUME")) return parseAssumeProve();
2225
+ if (peek().kind === "Keyword" && NEW_SYMBOL_STARTS.has(peek().text))
2226
+ return isTlapm ? commit(parseNewSymbol) : parseNewSymbol();
2227
+ if (!isTlapm) return parseExpression();
2228
+ // expr_or_sequent: where no expression starts, the sequent's ASSUME fails last.
2229
+ const expression = attempt(parseExpression);
2230
+ if (expression === undefined) throw createUnexpected("Expected a hypothesis");
2231
+ return expression;
2232
+ };
2233
+
2234
+ // comma1 (hyp b): Pco.star attempts the hypotheses after the first, each inside the one before,
2235
+ // so a failure that backtracks ends the list, and tlapm reports any other before the first comma.
2236
+ const parseTlapmHypotheses = () => {
2237
+ const assumptions = [parseHypothesis()];
2238
+ withRestorePoint(() => {
2239
+ while (true) {
2240
+ const assumption = attempt(() => {
2241
+ expect(",");
2242
+ return parseHypothesis();
2243
+ });
2244
+ if (assumption === undefined) break;
2245
+ assumptions.push(assumption);
2246
+ }
2247
+ });
2248
+ return assumptions;
2249
+ };
2250
+
1861
2251
  const parseAssumeProve = (): AssumeProve => {
1862
2252
  const start = cursor;
1863
2253
  const location = getLocation(expect("ASSUME"));
1864
- const assumptions = parseSeparated(() => {
1865
- if (peek().kind === "Identifier" && isAt("::", 1) && isAt("ASSUME", 2)) {
1866
- advance();
1867
- advance();
1868
- }
1869
- if (isAt("ASSUME")) return withProofScope(parseAssumeProve);
1870
- if (peek().kind === "Keyword" && NEW_SYMBOL_STARTS.has(peek().text)) return parseNewSymbol();
1871
- return parseExpression();
1872
- });
1873
- expect("PROVE");
1874
- return withRange(
1875
- { kind: "AssumeProve", assumptions, conclusion: parseExpression(), location },
1876
- start,
1877
- );
2254
+ const parseSequent = (): AssumeProve => {
2255
+ const assumptions = isTlapm ? parseTlapmHypotheses() : parseSeparated(parseHypothesis);
2256
+ expect("PROVE");
2257
+ return withRange(
2258
+ { kind: "AssumeProve", assumptions, conclusion: parseExpression(), location },
2259
+ start,
2260
+ );
2261
+ };
2262
+ return isTlapm ? commit(parseSequent) : parseSequent();
1878
2263
  };
1879
2264
 
1880
2265
  const isNameListAhead = (terminator: string) => {
@@ -1885,19 +2270,10 @@ const parse = (
1885
2270
  return peek(offset).kind === "Identifier" && isAt(terminator, offset + 1);
1886
2271
  };
1887
2272
 
1888
- const declareProofSymbols = (names: string[], bounds: Bound[]) => {
1889
- names.forEach(declareProofSymbol);
1890
- bounds.forEach((bound) =>
1891
- (bound.pattern.kind === "Name" ? [bound.pattern.name] : bound.pattern.names).forEach(
1892
- declareProofSymbol,
1893
- ),
1894
- );
1895
- };
1896
-
1897
2273
  const parseStepBody = (): StepBody => {
1898
2274
  const token = peek();
1899
2275
  if (isAt("USE") || isAt("HIDE")) return parseUseOrHide();
1900
- if (isAt("INSTANCE")) {
2276
+ if (!isTlapm && isAt("INSTANCE")) {
1901
2277
  const start = cursor;
1902
2278
  return withRange(parseInstance(undefined, [], false, getLocation(token)), start);
1903
2279
  }
@@ -1914,7 +2290,6 @@ const parse = (
1914
2290
  const isBounded = isBoundAhead();
1915
2291
  const names = getNames(isBounded ? [] : parseSeparated(expectName));
1916
2292
  const bounds = isBounded ? parseBounds() : [];
1917
- declareProofSymbols(names.names, bounds);
1918
2293
  return { kind: "Take", names: names.names, nameRanges: names.ranges, bounds };
1919
2294
  }
1920
2295
  if (accept("WITNESS")) {
@@ -1924,7 +2299,6 @@ const parse = (
1924
2299
  const isNames = isNameListAhead(":");
1925
2300
  const names = getNames(isNames ? parseSeparated(expectName) : []);
1926
2301
  const bounds = isNames ? [] : parseBounds();
1927
- declareProofSymbols(names.names, bounds);
1928
2302
  expect(":");
1929
2303
  return {
1930
2304
  kind: "Pick",
@@ -1961,8 +2335,6 @@ const parse = (
1961
2335
  const start = cursor;
1962
2336
  const step = parseStepStart(isAt("QED", 1));
1963
2337
  const statementStart = cursor;
1964
- const scope = new Set<string>();
1965
- proofScopes.push(scope);
1966
2338
  const body: StepBody = accept("QED") ? { kind: "Qed" } : parseStepBody();
1967
2339
  const head = getRange(start);
1968
2340
  const statement = getRange(statementStart);
@@ -1971,8 +2343,6 @@ const parse = (
1971
2343
  throw createError("Proof of a step that does not take a proof");
1972
2344
  }
1973
2345
  const proof = hasProof ? parseProof() : undefined;
1974
- proofScopes.pop();
1975
- if (body.kind !== "Assert" || body.isSuffices) scope.forEach(declareProofSymbol);
1976
2346
  return withRange({ ...step, body, head, statement, proof }, start);
1977
2347
  };
1978
2348
 
@@ -2004,7 +2374,7 @@ const parse = (
2004
2374
  const parseProof = (): Proof => {
2005
2375
  const start = cursor;
2006
2376
  proofLevels.push(-1);
2007
- const proof = withProofScope(parseProofBody);
2377
+ const proof = parseProofBody();
2008
2378
  proofLevels.pop();
2009
2379
  return withRange(proof, start);
2010
2380
  };
@@ -2086,20 +2456,26 @@ const parse = (
2086
2456
  throw createProofError(
2087
2457
  `Unexpected end of (sub)proof at level ${level} before QED step`,
2088
2458
  levelSpan,
2459
+ NEWLINES,
2089
2460
  );
2090
2461
  }
2091
2462
  if (item.kind === "Leaf") {
2092
2463
  throw createProofError(
2093
2464
  `Expecting a proof step but found a${LEAF_NAMES[item.proof.kind]} leaf proof`,
2094
2465
  item.span,
2466
+ NEWLINES,
2095
2467
  );
2096
2468
  }
2097
2469
  if (!isFirst && item.isProof) {
2098
- throw createProofError("PROOF keyword found in step that does not begin subproof", item.span);
2470
+ throw createProofError(
2471
+ "PROOF keyword found in step that does not begin subproof",
2472
+ item.span,
2473
+ PRINTED_NEWLINE,
2474
+ );
2099
2475
  }
2100
2476
  const implicit = item.token.text[1];
2101
2477
  if (implicit === "+" && !isFirst) {
2102
- throw createProofError("<+> used but no subproof expected", item.span);
2478
+ throw createProofError("<+> used but no subproof expected", item.span, PRINTED_NEWLINE);
2103
2479
  }
2104
2480
  const stepLevel =
2105
2481
  implicit === "*"
@@ -2154,6 +2530,7 @@ const parse = (
2154
2530
  throw createProofError(
2155
2531
  "extra step(s) after finished proof",
2156
2532
  extra.span,
2533
+ NO_NEWLINES,
2157
2534
  "Proof.Parser.toplevel",
2158
2535
  );
2159
2536
  }
@@ -2181,25 +2558,26 @@ const parse = (
2181
2558
  const parseFactName = () => {
2182
2559
  if (peek().kind !== "Identifier" || !isAt("==", 1)) return undefined;
2183
2560
  const name = expectIdentifier();
2184
- factNames.add(name);
2185
2561
  advance();
2186
2562
  return name;
2187
2563
  };
2188
2564
 
2565
+ // A theorem whose statement fails to start backtracks in tlapm, whose module ends there.
2566
+ const parseTheoremExpression = () => {
2567
+ if (!isTlapm) return parseExpression();
2568
+ const token = peekRaw();
2569
+ const statement = attempt(parseExpression);
2570
+ if (statement) return statement;
2571
+ throw createUnexpected(`Expected "====" but found ${describeToken(token)}`, token);
2572
+ };
2573
+
2189
2574
  const parseTheorem = (module: Module) => {
2190
2575
  const start = cursor;
2191
2576
  const keyword = advance();
2192
2577
  const name = parseFactName();
2193
- const parsed = withProofScope(() => {
2194
- const statement = isAt("ASSUME") ? parseAssumeProve() : parseExpression();
2195
- if (isTlapm) return { statement, proof: parseTlapmProof() };
2196
- return { statement, proof: isProofStart(peek()) ? parseProof() : undefined };
2197
- });
2198
- const statement = parsed.statement;
2199
- const theorem = withRange(
2200
- { name, statement, proof: parsed.proof, location: getLocation(keyword) },
2201
- start,
2202
- );
2578
+ const statement = isAt("ASSUME") ? parseAssumeProve() : parseTheoremExpression();
2579
+ const proof = isTlapm ? parseTlapmProof() : isProofStart(peek()) ? parseProof() : undefined;
2580
+ const theorem = withRange({ name, statement, proof, location: getLocation(keyword) }, start);
2203
2581
  module.theorems.push(theorem);
2204
2582
  module.units.push({ kind: "Theorem", theorem });
2205
2583
  if (name === undefined || statement.kind === "AssumeProve") return;
@@ -2252,7 +2630,6 @@ const parse = (
2252
2630
  }
2253
2631
  while (true) {
2254
2632
  const tokenIndex = cursor;
2255
- unitStart = tokenIndex;
2256
2633
  const token = peek();
2257
2634
  if (token.kind === "ModuleEnd") {
2258
2635
  location.range = {