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.
- package/README.md +2 -1
- package/dist/compile.cjs +3 -3
- package/dist/compile.js +1 -1
- package/dist/deciders.cjs +41 -37
- package/dist/deciders.js +45 -41
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +5 -1
- package/dist/index.d.ts +5 -1
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove-worker.cjs +1 -1
- package/dist/prove-worker.js +1 -1
- package/dist/prove.cjs +2682 -426
- package/dist/prove.js +2679 -423
- package/dist/run.cjs +43 -42
- package/dist/run.js +44 -43
- package/dist/tlapm.cjs +1 -1
- package/dist/tlapm.js +1 -1
- package/dist/transfer.cjs +43 -40
- package/dist/transfer.js +43 -40
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +4 -3
- package/src/bags.ts +46 -28
- package/src/check-trace.ts +2 -16
- package/src/check.ts +349 -91
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/tlapm.ts +424 -62
- package/src/cli/tlc-arguments.ts +2 -2
- package/src/cli/tlc-output.ts +4 -5
- package/src/cli/tlc-usage.ts +0 -1
- package/src/cli/tlc.ts +26 -7
- package/src/cli/xml-exporter.ts +1 -1
- package/src/codegen.ts +9 -5
- package/src/dependencies.ts +72 -11
- package/src/dfid.ts +9 -2
- package/src/environment.ts +65 -36
- package/src/errors.ts +38 -3
- package/src/evaluate.ts +92 -32
- package/src/exit-codes.ts +5 -2
- package/src/instances.ts +5 -5
- package/src/java-overrides.ts +2 -2
- package/src/levels.ts +138 -90
- package/src/lexer.ts +5 -3
- package/src/liveness-checker.ts +572 -204
- package/src/liveness.ts +47 -32
- package/src/obligations/action.ts +10 -6
- package/src/obligations/anonymize.ts +33 -14
- package/src/obligations/enabled-axioms.ts +218 -0
- package/src/obligations/equality.ts +1 -3
- package/src/obligations/expression.ts +18 -6
- package/src/obligations/format.ts +0 -2
- package/src/obligations/generate.ts +22 -17
- package/src/obligations/index.ts +37 -7
- package/src/obligations/levels.ts +24 -11
- package/src/obligations/module.ts +1 -3
- package/src/obligations/normalize.ts +25 -17
- package/src/obligations/operators.ts +0 -2
- package/src/obligations/pragma.ts +53 -16
- package/src/obligations/printer.ts +48 -18
- package/src/obligations/proof.ts +3 -2
- package/src/obligations/regroup.ts +0 -2
- package/src/obligations/simplify.ts +17 -7
- package/src/obligations/source.ts +71 -17
- package/src/obligations/subexpression.ts +45 -18
- package/src/obligations/substitution.ts +1 -3
- package/src/obligations/temporal.ts +0 -2
- package/src/obligations/tuples.ts +0 -2
- package/src/parallel-worker.ts +8 -2
- package/src/parallel.ts +7 -2
- package/src/parser.ts +664 -287
- package/src/pretty-print.ts +1 -1
- package/src/prover/deciders.ts +11 -8
- package/src/prover/isabelle/decide.ts +3 -25
- package/src/prover/isabelle/encode.ts +71 -41
- package/src/prover/isabelle/isar/attrib.ts +250 -0
- package/src/prover/isabelle/isar/context.ts +335 -0
- package/src/prover/isabelle/isar/induct.ts +382 -0
- package/src/prover/isabelle/isar/inner-syntax.ts +149 -3
- package/src/prover/isabelle/isar/method.ts +506 -198
- package/src/prover/isabelle/isar/proof.ts +570 -14
- package/src/prover/isabelle/isar/rule-cases.ts +226 -0
- package/src/prover/isabelle/isar/theory.ts +479 -69
- package/src/prover/isabelle/isar/toplevel.ts +331 -0
- package/src/prover/isabelle/isar/type-check.ts +83 -8
- package/src/prover/isabelle/provers/blast/blast.ts +0 -2
- package/src/prover/isabelle/provers/blast/branch.ts +0 -2
- package/src/prover/isabelle/provers/blast/prove.ts +0 -2
- package/src/prover/isabelle/provers/blast/rules.ts +0 -2
- package/src/prover/isabelle/provers/blast/state.ts +0 -2
- package/src/prover/isabelle/provers/blast/term.ts +0 -2
- package/src/prover/isabelle/provers/clasimp.ts +1 -3
- package/src/prover/isabelle/provers/classical.ts +45 -20
- package/src/prover/isabelle/provers/hypsubst.ts +2 -4
- package/src/prover/isabelle/pure/bicompose.ts +0 -2
- package/src/prover/isabelle/pure/consts.ts +0 -2
- package/src/prover/isabelle/pure/conv.ts +0 -2
- package/src/prover/isabelle/pure/drule.ts +63 -4
- package/src/prover/isabelle/pure/envir.ts +0 -2
- package/src/prover/isabelle/pure/goal.ts +1 -3
- package/src/prover/isabelle/pure/logic.ts +0 -2
- package/src/prover/isabelle/pure/name.ts +0 -2
- package/src/prover/isabelle/pure/net.ts +0 -2
- package/src/prover/isabelle/pure/object-logic.ts +13 -7
- package/src/prover/isabelle/pure/pattern.ts +0 -2
- package/src/prover/isabelle/pure/raw-simplifier.ts +0 -2
- package/src/prover/isabelle/pure/rewriter.ts +4 -11
- package/src/prover/isabelle/pure/search.ts +0 -2
- package/src/prover/isabelle/pure/seq.ts +0 -2
- package/src/prover/isabelle/pure/simplifier.ts +26 -7
- package/src/prover/isabelle/pure/table.ts +0 -2
- package/src/prover/isabelle/pure/tactic.ts +0 -2
- package/src/prover/isabelle/pure/tactical.ts +0 -2
- package/src/prover/isabelle/pure/term-ord.ts +0 -2
- package/src/prover/isabelle/pure/term.ts +3 -5
- package/src/prover/isabelle/pure/thm.ts +0 -2
- package/src/prover/isabelle/pure/type.ts +0 -2
- package/src/prover/isabelle/pure/unify.ts +0 -2
- package/src/prover/isabelle/pure/variable.ts +0 -2
- package/src/prover/isabelle/tla/classical-setup.ts +1 -2
- package/src/prover/isabelle/tla/context.ts +51 -9
- package/src/prover/isabelle/tla/logic-data.ts +1 -1
- package/src/prover/isabelle/tla/logic.ts +40 -1
- package/src/prover/isabelle/tla/simpdata.ts +0 -2
- package/src/prover/isabelle/tools/intuitionistic.ts +28 -12
- package/src/prover/ocaml.ts +4 -1
- package/src/prover/prep/action.ts +19 -12
- package/src/prover/prep/enabled-axioms.ts +11 -2
- package/src/prover/prep/md5.ts +26 -29
- package/src/prover/prep/methods.ts +159 -50
- package/src/prover/prep/normalize.ts +38 -9
- package/src/prover/prove.ts +343 -65
- package/src/prover/ptl/decide.ts +95 -50
- package/src/prover/ptl/encode.ts +2 -3
- package/src/prover/ptl/tableau.ts +28 -2
- package/src/prover/smt/arithmetic.ts +310 -0
- package/src/prover/smt/axioms.ts +12 -8
- package/src/prover/smt/context.ts +42 -6
- package/src/prover/smt/data.ts +191 -84
- package/src/prover/smt/encode.ts +122 -43
- package/src/prover/smt/extensionality.ts +5 -3
- package/src/prover/smt/flatten.ts +4 -6
- package/src/prover/smt/format.ts +28 -4
- package/src/prover/smt/instances.ts +7 -1
- package/src/prover/smt/layout.ts +91 -0
- package/src/prover/smt/rewrite.ts +483 -116
- package/src/prover/smt/simplify.ts +441 -0
- package/src/prover/smt/solver/ackermannize-bv-tactic.ts +61 -0
- package/src/prover/smt/solver/ackr-helper.ts +179 -0
- package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
- package/src/prover/smt/solver/act-cache.ts +0 -1
- package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
- package/src/prover/smt/solver/aig-tactic.ts +52 -0
- package/src/prover/smt/solver/aig.ts +889 -0
- package/src/prover/smt/solver/arith-rewriter.ts +613 -6
- package/src/prover/smt/solver/arith-terms.ts +121 -0
- package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
- package/src/prover/smt/solver/array-rewriter.ts +309 -0
- package/src/prover/smt/solver/asserted-formulas.ts +93 -15
- package/src/prover/smt/solver/ast-lt.ts +165 -11
- package/src/prover/smt/solver/ast-util.ts +160 -2
- package/src/prover/smt/solver/ast.ts +1449 -41
- package/src/prover/smt/solver/auf-solver.ts +0 -1
- package/src/prover/smt/solver/bit-blast-tactic.ts +582 -0
- package/src/prover/smt/solver/bit-blaster.ts +871 -0
- package/src/prover/smt/solver/bound-manager.ts +196 -0
- package/src/prover/smt/solver/bound-simplifier.ts +600 -0
- package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
- package/src/prover/smt/solver/bv-decl-plugin.ts +341 -0
- package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
- package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
- package/src/prover/smt/solver/bv1-blast.ts +214 -0
- package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
- package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
- package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
- package/src/prover/smt/solver/card2bv.ts +109 -0
- package/src/prover/smt/solver/case-split-queue.ts +0 -2
- package/src/prover/smt/solver/cg-table.ts +39 -25
- package/src/prover/smt/solver/check-logic.ts +330 -0
- package/src/prover/smt/solver/clause.ts +0 -1
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +278 -0
- package/src/prover/smt/solver/conflict-resolution.ts +78 -2
- package/src/prover/smt/solver/context.ts +533 -114
- package/src/prover/smt/solver/ctx-simplify.ts +21 -12
- package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
- package/src/prover/smt/solver/datatype-decl-plugin.ts +572 -0
- package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
- package/src/prover/smt/solver/demodulator.ts +786 -0
- package/src/prover/smt/solver/dependent-expr-state.ts +81 -0
- package/src/prover/smt/solver/der.ts +38 -10
- package/src/prover/smt/solver/diff-neq.ts +205 -0
- package/src/prover/smt/solver/distribute-forall.ts +57 -0
- package/src/prover/smt/solver/dom-simplify.ts +511 -0
- package/src/prover/smt/solver/dt2bv-tactic.ts +260 -0
- package/src/prover/smt/solver/dyn-ack.ts +0 -1
- package/src/prover/smt/solver/e-matching.ts +6 -7
- package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +542 -0
- package/src/prover/smt/solver/enode.ts +100 -3
- package/src/prover/smt/solver/eq2bv-tactic.ts +218 -0
- package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
- package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
- package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
- package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
- package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
- package/src/prover/smt/solver/euf/array-solver.ts +306 -0
- package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
- package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
- package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
- package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
- package/src/prover/smt/solver/euf/egraph.ts +901 -0
- package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
- package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
- package/src/prover/smt/solver/euf/mam.ts +1046 -0
- package/src/prover/smt/solver/euf/q-ematch.ts +829 -0
- package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
- package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
- package/src/prover/smt/solver/euf/q-solver.ts +361 -0
- package/src/prover/smt/solver/euf/th-solver.ts +328 -0
- package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
- package/src/prover/smt/solver/expr-ref.ts +0 -1
- package/src/prover/smt/solver/expr-safe-replace.ts +26 -2
- package/src/prover/smt/solver/expr2polynomial.ts +271 -0
- package/src/prover/smt/solver/factor.ts +163 -0
- package/src/prover/smt/solver/fd-solver.ts +267 -0
- package/src/prover/smt/solver/fingerprints.ts +15 -15
- package/src/prover/smt/solver/fix-dl-var.ts +147 -0
- package/src/prover/smt/solver/flat-literals.ts +0 -1
- package/src/prover/smt/solver/fm-tactic.ts +884 -0
- package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
- package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
- package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
- package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
- package/src/prover/smt/solver/goal.ts +177 -15
- package/src/prover/smt/solver/goal2nlsat.ts +216 -0
- package/src/prover/smt/solver/guard-set.ts +219 -0
- package/src/prover/smt/solver/hash.ts +0 -1
- package/src/prover/smt/solver/hashtable.ts +30 -16
- package/src/prover/smt/solver/inf-eps.ts +63 -0
- package/src/prover/smt/solver/inj-axiom.ts +101 -0
- package/src/prover/smt/solver/internalizer.ts +109 -36
- package/src/prover/smt/solver/lackr.ts +381 -0
- package/src/prover/smt/solver/lbool.ts +0 -1
- package/src/prover/smt/solver/lia2card.ts +268 -0
- package/src/prover/smt/solver/lia2pb.ts +154 -0
- package/src/prover/smt/solver/literal.ts +0 -1
- package/src/prover/smt/solver/logic-tactics.ts +345 -0
- package/src/prover/smt/solver/lp/bound-propagator.ts +0 -1
- package/src/prover/smt/solver/lp/constraints.ts +0 -1
- package/src/prover/smt/solver/lp/containers.ts +7 -2
- package/src/prover/smt/solver/lp/core-solver.ts +18 -3
- package/src/prover/smt/solver/lp/cross-nested.ts +1 -4
- package/src/prover/smt/solver/lp/dep-intervals.ts +0 -3
- package/src/prover/smt/solver/lp/dependency.ts +0 -2
- package/src/prover/smt/solver/lp/dioph-eq.ts +0 -2
- package/src/prover/smt/solver/lp/explanation.ts +0 -1
- package/src/prover/smt/solver/lp/gomory.ts +0 -1
- package/src/prover/smt/solver/lp/hnf-cutter.ts +0 -1
- package/src/prover/smt/solver/lp/hnf.ts +0 -3
- package/src/prover/smt/solver/lp/int-cube.ts +3 -4
- package/src/prover/smt/solver/lp/int-solver.ts +0 -2
- package/src/prover/smt/solver/lp/lar-solver.ts +40 -4
- package/src/prover/smt/solver/lp/lar-term.ts +0 -1
- package/src/prover/smt/solver/lp/lp-settings.ts +0 -1
- package/src/prover/smt/solver/lp/maximize-term.ts +59 -10
- package/src/prover/smt/solver/lp/nex-creator.ts +3 -3
- package/src/prover/smt/solver/lp/nex.ts +2 -2
- package/src/prover/smt/solver/lp/nla-backoff.ts +0 -2
- package/src/prover/smt/solver/lp/nla-basics.ts +46 -3
- package/src/prover/smt/solver/lp/nla-core.ts +66 -11
- package/src/prover/smt/solver/lp/nla-divisions.ts +0 -2
- package/src/prover/smt/solver/lp/nla-emonics.ts +0 -1
- package/src/prover/smt/solver/lp/nla-factorization.ts +0 -1
- package/src/prover/smt/solver/lp/nla-grobner.ts +167 -85
- package/src/prover/smt/solver/lp/nla-horner.ts +0 -2
- package/src/prover/smt/solver/lp/nla-intervals.ts +0 -1
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +0 -2
- package/src/prover/smt/solver/lp/nla-monotone.ts +0 -1
- package/src/prover/smt/solver/lp/nla-order.ts +0 -2
- package/src/prover/smt/solver/lp/nla-patcher.ts +0 -1
- package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
- package/src/prover/smt/solver/lp/nla-tangents.ts +0 -2
- package/src/prover/smt/solver/lp/nla-throttle.ts +0 -1
- package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
- package/src/prover/smt/solver/lp/nla-types.ts +0 -2
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +0 -1
- package/src/prover/smt/solver/lp/nra-solver.ts +163 -99
- package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
- package/src/prover/smt/solver/lp/pdd-interval.ts +6 -3
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -21
- package/src/prover/smt/solver/lp/pdd-solver.ts +72 -41
- package/src/prover/smt/solver/lp/pdd.ts +725 -290
- package/src/prover/smt/solver/lp/random-updater.ts +0 -2
- package/src/prover/smt/solver/lp/static-matrix.ts +0 -1
- package/src/prover/smt/solver/lp/union-find.ts +7 -2
- package/src/prover/smt/solver/macro-finder.ts +530 -0
- package/src/prover/smt/solver/mam-compiler.ts +118 -88
- package/src/prover/smt/solver/mam-interpreter.ts +0 -1
- package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
- package/src/prover/smt/solver/max-cliques.ts +105 -0
- package/src/prover/smt/solver/maxcore.ts +309 -0
- package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -6
- package/src/prover/smt/solver/maxlex.ts +115 -0
- package/src/prover/smt/solver/maxsmt-base.ts +105 -0
- package/src/prover/smt/solver/maxsmt.ts +92 -0
- package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
- package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
- package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
- package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
- package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
- package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
- package/src/prover/smt/solver/model-based-opt.ts +844 -0
- package/src/prover/smt/solver/model-checker.ts +17 -26
- package/src/prover/smt/solver/model-evaluator.ts +188 -12
- package/src/prover/smt/solver/model-finder.ts +0 -1
- package/src/prover/smt/solver/model-generator.ts +59 -30
- package/src/prover/smt/solver/model-macro-solver.ts +38 -27
- package/src/prover/smt/solver/model-printer.ts +214 -0
- package/src/prover/smt/solver/mpf.ts +709 -0
- package/src/prover/smt/solver/mus.ts +50 -0
- package/src/prover/smt/solver/muz/dl-context.ts +410 -0
- package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
- package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
- package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
- package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
- package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
- package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
- package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
- package/src/prover/smt/solver/muz/dl-rule.ts +496 -0
- package/src/prover/smt/solver/muz/hnf.ts +201 -0
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
- package/src/prover/smt/solver/muz/horn-tactic.ts +201 -0
- package/src/prover/smt/solver/muz/rule-properties.ts +337 -0
- package/src/prover/smt/solver/muz/spacer-context.ts +1404 -0
- package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
- package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
- package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
- package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
- package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
- package/src/prover/smt/solver/muz/substitution.ts +203 -0
- package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
- package/src/prover/smt/solver/nlqsat.ts +484 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +305 -88
- package/src/prover/smt/solver/nlsat/atoms.ts +52 -35
- package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
- package/src/prover/smt/solver/nlsat/explain.ts +424 -211
- package/src/prover/smt/solver/nlsat/interval-set.ts +1 -2
- package/src/prover/smt/solver/nlsat/levelwise.ts +460 -241
- package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
- package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -683
- package/src/prover/smt/solver/nlsat/solver.ts +282 -69
- package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
- package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
- package/src/prover/smt/solver/nlsat/types.ts +0 -2
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -7
- package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -20
- package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
- package/src/prover/smt/solver/nnf.ts +105 -23
- package/src/prover/smt/solver/normalize-bounds.ts +53 -0
- package/src/prover/smt/solver/occf.ts +97 -0
- package/src/prover/smt/solver/opt-context.ts +792 -0
- package/src/prover/smt/solver/opt-nlsat.ts +386 -0
- package/src/prover/smt/solver/opt-pareto.ts +282 -0
- package/src/prover/smt/solver/opt-preprocess.ts +101 -0
- package/src/prover/smt/solver/opt-solver.ts +311 -0
- package/src/prover/smt/solver/opt-value.ts +55 -0
- package/src/prover/smt/solver/optsmt.ts +692 -0
- package/src/prover/smt/solver/parallel-tactic.ts +299 -0
- package/src/prover/smt/solver/pattern-inference.ts +19 -11
- package/src/prover/smt/solver/pb-rewriter.ts +281 -0
- package/src/prover/smt/solver/pb2bv-tactic.ts +540 -0
- package/src/prover/smt/solver/poly-rewriter.ts +202 -57
- package/src/prover/smt/solver/probes.ts +511 -0
- package/src/prover/smt/solver/propagate-values.ts +37 -21
- package/src/prover/smt/solver/proto-model.ts +650 -17
- package/src/prover/smt/solver/pull-quant.ts +28 -12
- package/src/prover/smt/solver/purify-arith.ts +632 -0
- package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -0
- package/src/prover/smt/solver/qe-lite-der.ts +2 -3
- package/src/prover/smt/solver/qe-lite-fm.ts +3 -4
- package/src/prover/smt/solver/qe-lite.ts +37 -17
- package/src/prover/smt/solver/qe-mbp.ts +270 -0
- package/src/prover/smt/solver/qe.ts +1499 -0
- package/src/prover/smt/solver/qel.ts +25 -0
- package/src/prover/smt/solver/qi-queue.ts +0 -1
- package/src/prover/smt/solver/qsat.ts +814 -0
- package/src/prover/smt/solver/quant-hoist.ts +196 -0
- package/src/prover/smt/solver/quant-tactics.ts +16 -56
- package/src/prover/smt/solver/quantifier-analyzer.ts +9 -10
- package/src/prover/smt/solver/quantifier-manager.ts +25 -24
- package/src/prover/smt/solver/quasi-macros.ts +243 -0
- package/src/prover/smt/solver/random-gen.ts +0 -1
- package/src/prover/smt/solver/rational.ts +45 -1
- package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -0
- package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
- package/src/prover/smt/solver/reduce-args.ts +225 -0
- package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
- package/src/prover/smt/solver/ref-vector.ts +0 -1
- package/src/prover/smt/solver/relevancy.ts +1 -2
- package/src/prover/smt/solver/rewriter-tpl.ts +77 -10
- package/src/prover/smt/solver/rewriter.ts +475 -36
- package/src/prover/smt/solver/rlimit.ts +38 -2
- package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
- package/src/prover/smt/solver/sat/big.ts +177 -0
- package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
- package/src/prover/smt/solver/sat/clause.ts +203 -0
- package/src/prover/smt/solver/sat/cleaner.ts +94 -0
- package/src/prover/smt/solver/sat/config.ts +122 -0
- package/src/prover/smt/solver/sat/consequences.ts +203 -0
- package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
- package/src/prover/smt/solver/sat/goal2sat.ts +526 -0
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +378 -0
- package/src/prover/smt/solver/sat/model-converter.ts +136 -0
- package/src/prover/smt/solver/sat/pb-constraint.ts +261 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +1577 -0
- package/src/prover/smt/solver/sat/probing.ts +170 -0
- package/src/prover/smt/solver/sat/sat-tactic.ts +44 -0
- package/src/prover/smt/solver/sat/sat2goal.ts +165 -0
- package/src/prover/smt/solver/sat/scc.ts +142 -0
- package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
- package/src/prover/smt/solver/sat/solver.ts +2105 -0
- package/src/prover/smt/solver/sat/var-queue.ts +117 -0
- package/src/prover/smt/solver/sat/watch-list.ts +140 -0
- package/src/prover/smt/solver/search-tree.ts +284 -0
- package/src/prover/smt/solver/seq-axioms.ts +995 -0
- package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
- package/src/prover/smt/solver/seq-derive.ts +1298 -0
- package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
- package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
- package/src/prover/smt/solver/seq-factory.ts +89 -0
- package/src/prover/smt/solver/seq-monadic.ts +730 -0
- package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
- package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -0
- package/src/prover/smt/solver/seq-re-util.ts +758 -0
- package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
- package/src/prover/smt/solver/seq-regex-live.ts +200 -0
- package/src/prover/smt/solver/seq-rewriter.ts +2404 -0
- package/src/prover/smt/solver/seq-skolem.ts +294 -0
- package/src/prover/smt/solver/seq-subset.ts +165 -0
- package/src/prover/smt/solver/seq-view-witness.ts +353 -0
- package/src/prover/smt/solver/smt-consequences.ts +297 -0
- package/src/prover/smt/solver/smt-kernel.ts +90 -0
- package/src/prover/smt/solver/smt-logics.ts +66 -0
- package/src/prover/smt/solver/smt-setup.ts +544 -0
- package/src/prover/smt/solver/smt2-printer.ts +765 -0
- package/src/prover/smt/solver/smtlib-parser.ts +3228 -327
- package/src/prover/smt/solver/smtlib-script.ts +1843 -0
- package/src/prover/smt/solver/solve-eqs.ts +923 -0
- package/src/prover/smt/solver/solver.ts +113 -22
- package/src/prover/smt/solver/static-features.ts +314 -0
- package/src/prover/smt/solver/sticky-generations.ts +0 -1
- package/src/prover/smt/solver/tactic.ts +2012 -0
- package/src/prover/smt/solver/term-enumeration.ts +205 -0
- package/src/prover/smt/solver/theory-array.ts +1240 -0
- package/src/prover/smt/solver/theory-bv.ts +1200 -0
- package/src/prover/smt/solver/theory-char.ts +355 -0
- package/src/prover/smt/solver/theory-datatype.ts +598 -0
- package/src/prover/smt/solver/theory-finite-set.ts +30 -0
- package/src/prover/smt/solver/theory-fpa.ts +389 -0
- package/src/prover/smt/solver/theory-lra-axioms.ts +53 -2
- package/src/prover/smt/solver/theory-lra-bounds.ts +31 -5
- package/src/prover/smt/solver/theory-lra-final-check.ts +56 -71
- package/src/prover/smt/solver/theory-lra-internalize.ts +89 -11
- package/src/prover/smt/solver/theory-lra-model.ts +20 -35
- package/src/prover/smt/solver/theory-lra-propagate.ts +24 -28
- package/src/prover/smt/solver/theory-lra-state.ts +6 -22
- package/src/prover/smt/solver/theory-lra.ts +188 -2
- package/src/prover/smt/solver/theory-pb.ts +933 -0
- package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
- package/src/prover/smt/solver/theory-recfun.ts +307 -0
- package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
- package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
- package/src/prover/smt/solver/theory-seq-state.ts +852 -0
- package/src/prover/smt/solver/theory-seq.ts +961 -0
- package/src/prover/smt/solver/theory.ts +189 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +485 -0
- package/src/prover/smt/solver/var-subst.ts +36 -14
- package/src/prover/smt/table.ts +3 -2
- package/src/prover/smt/types.ts +146 -0
- package/src/prover/tlapm/cache.ts +37 -16
- package/src/prover/tlapm-library.ts +3208 -0
- package/src/prover/verdict.ts +2 -0
- package/src/prover/zenon/decide.ts +10 -7
- package/src/prover/zenon/encode.ts +0 -2
- package/src/prover/zenon/eqrel.ts +0 -2
- package/src/prover/zenon/equality-rules.ts +24 -2
- package/src/prover/zenon/expr.ts +21 -2
- package/src/prover/zenon/index-table.ts +7 -4
- package/src/prover/zenon/isar-case.ts +1 -3
- package/src/prover/zenon/isar.ts +2 -4
- package/src/prover/zenon/llproof.ts +0 -2
- package/src/prover/zenon/mltoll.ts +0 -2
- package/src/prover/zenon/node.ts +20 -5
- package/src/prover/zenon/parse.ts +6 -2
- package/src/prover/zenon/phrase.ts +1 -3
- package/src/prover/zenon/proof.ts +0 -2
- package/src/prover/zenon/propositional-rules.ts +0 -2
- package/src/prover/zenon/rules.ts +2 -3
- package/src/prover/zenon/search.ts +7 -5
- package/src/prover/zenon/tla/functions.ts +0 -2
- package/src/prover/zenon/tla/llproof.ts +0 -2
- package/src/prover/zenon/tla/records.ts +0 -2
- package/src/prover/zenon/tla/rewrites.ts +0 -2
- package/src/prover/zenon/tla/sets.ts +7 -8
- package/src/prover/zenon/tla/terms.ts +0 -2
- package/src/prover/zenon/tla/tla.ts +0 -2
- package/src/resolve.ts +625 -189
- package/src/runtime.ts +7 -1
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +2 -13
- package/src/sany/generator-definitions.ts +3 -1
- package/src/sany/generator-expressions.ts +36 -30
- package/src/sany/generator-proofs.ts +5 -3
- package/src/sany/generator.ts +2 -1
- package/src/sany/levels.ts +0 -2
- package/src/sany/lexer.ts +3 -3
- package/src/sany/linter.ts +0 -2
- package/src/sany/modules.ts +4 -2
- package/src/sany/nodes.ts +1 -1
- package/src/sany/selectors.ts +11 -6
- package/src/sany/xml.ts +2 -3
- package/src/search.ts +209 -56
- package/src/simulate.ts +3 -0
- package/src/spec-description.ts +2 -2
- package/src/standard-definitions.ts +4 -0
- package/src/state-graph.ts +0 -2
- package/src/subexpressions.ts +265 -94
- package/src/successors.ts +2 -1
- package/src/symmetry.ts +3 -3
- package/src/tableau.ts +2 -2
- package/src/tlc/fingerprint.ts +81 -9
- package/src/tlc/jar-data.ts +10 -0
- package/src/tlc/messages.ts +3 -3
- package/src/tlc/order.ts +14 -3
- package/src/tlc/summary.ts +29 -14
- package/src/tlc/tlc-operators.ts +3 -1
- package/src/tlc/tlcext-operators.ts +61 -16
- package/src/tlc/trace-spec.ts +5 -5
- package/src/typed-tier.ts +6541 -0
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +46 -27
- package/src/prover/isabelle/isar/statement.ts +0 -52
- package/src/prover/smt/solver/z3-license.txt +0 -10
- package/src/prover/tlaps-module.ts +0 -510
- 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 {
|
|
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
|
-
|
|
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
|
-
|
|
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
|
|
526
|
-
|
|
527
|
-
|
|
528
|
-
}
|
|
529
|
-
|
|
530
|
-
|
|
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
|
|
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 =
|
|
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
|
-
|
|
659
|
-
|
|
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
|
-
}
|
|
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
|
-
|
|
846
|
-
|
|
847
|
-
|
|
848
|
-
|
|
849
|
-
|
|
850
|
-
|
|
851
|
-
|
|
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
|
|
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
|
|
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
|
-
|
|
1133
|
-
|
|
1134
|
-
|
|
1135
|
-
|
|
1136
|
-
|
|
1137
|
-
|
|
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
|
-
|
|
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
|
-
|
|
1171
|
-
|
|
1172
|
-
|
|
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 (
|
|
1175
|
-
return
|
|
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
|
-
|
|
1222
|
-
|
|
1223
|
-
|
|
1224
|
-
|
|
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 (
|
|
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: [
|
|
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
|
|
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
|
|
1543
|
+
if (DEFINABLE_POSTFIX_OPERATORS.has(token.text) && minimumPrecedence <= 15) {
|
|
1349
1544
|
advance();
|
|
1350
1545
|
lastOperator = POSTFIX_PRECEDENCE;
|
|
1351
|
-
left = withRange(
|
|
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
|
-
|
|
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 (
|
|
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
|
-
|
|
1402
|
-
|
|
1403
|
-
|
|
1404
|
-
|
|
1405
|
-
|
|
1406
|
-
|
|
1407
|
-
|
|
1408
|
-
|
|
1409
|
-
|
|
1410
|
-
|
|
1411
|
-
|
|
1412
|
-
|
|
1413
|
-
|
|
1414
|
-
|
|
1415
|
-
|
|
1416
|
-
|
|
1417
|
-
|
|
1418
|
-
|
|
1419
|
-
|
|
1420
|
-
|
|
1421
|
-
|
|
1422
|
-
|
|
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
|
-
|
|
1427
|
-
|
|
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
|
-
|
|
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
|
-
|
|
1769
|
-
|
|
1770
|
-
|
|
1771
|
-
|
|
1772
|
-
|
|
1773
|
-
|
|
1774
|
-
|
|
1775
|
-
|
|
1776
|
-
|
|
1777
|
-
|
|
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
|
-
|
|
1793
|
-
|
|
1794
|
-
|
|
1795
|
-
|
|
1796
|
-
|
|
1797
|
-
|
|
1798
|
-
|
|
1799
|
-
|
|
1800
|
-
|
|
1801
|
-
|
|
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
|
|
1865
|
-
|
|
1866
|
-
|
|
1867
|
-
|
|
1868
|
-
|
|
1869
|
-
|
|
1870
|
-
|
|
1871
|
-
|
|
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 =
|
|
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(
|
|
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
|
|
2194
|
-
|
|
2195
|
-
|
|
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 = {
|