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