tla-ts 0.0.4-dev.e4c2d0e → 0.0.4-dev.ee344a5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (311) hide show
  1. package/README.md +45 -1
  2. package/dist/deciders.cjs +366 -0
  3. package/dist/deciders.js +366 -0
  4. package/dist/index.cjs +1 -1
  5. package/dist/index.d.cts +35 -1
  6. package/dist/index.d.ts +35 -1
  7. package/dist/index.js +1 -1
  8. package/dist/parallel-worker.cjs +1 -4
  9. package/dist/parallel-worker.js +1 -4
  10. package/dist/prove-worker.cjs +9 -0
  11. package/dist/prove-worker.d.cts +9 -0
  12. package/dist/prove-worker.d.ts +9 -0
  13. package/dist/prove-worker.js +9 -0
  14. package/dist/prove.cjs +515 -0
  15. package/dist/prove.js +515 -0
  16. package/dist/run-cli.cjs +30 -47
  17. package/dist/run-cli.js +30 -47
  18. package/dist/tlapm.cjs +10 -0
  19. package/dist/tlapm.js +10 -0
  20. package/dist/transfer.cjs +38 -44
  21. package/dist/transfer.js +38 -44
  22. package/dist/worker.cjs +21 -0
  23. package/dist/worker.js +21 -0
  24. package/package.json +21 -12
  25. package/src/check.ts +1 -0
  26. package/src/codegen.ts +26 -7
  27. package/src/errors.ts +86 -0
  28. package/src/evaluate.ts +63 -20
  29. package/src/index.ts +10 -0
  30. package/src/{obligation-action.ts → obligations/action.ts} +258 -37
  31. package/src/{obligation-anon.ts → obligations/anon.ts} +13 -7
  32. package/src/obligations/ctx.ts +64 -0
  33. package/src/{obligation-deref.ts → obligations/deref.ts} +2 -2
  34. package/src/{obligation-expression.ts → obligations/expression.ts} +54 -8
  35. package/src/{obligation-generate.ts → obligations/generate.ts} +134 -61
  36. package/src/{obligations.ts → obligations/index.ts} +26 -12
  37. package/src/{obligation-levels.ts → obligations/levels.ts} +12 -2
  38. package/src/{obligation-module.ts → obligations/module.ts} +46 -20
  39. package/src/obligations/pickle.ts +100 -0
  40. package/src/obligations/pragma.ts +189 -0
  41. package/src/{obligation-printer.ts → obligations/printer.ts} +5 -59
  42. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -1
  43. package/src/{obligation-source.ts → obligations/source.ts} +91 -35
  44. package/src/obligations/temporal.ts +319 -0
  45. package/src/{obligation-tuples.ts → obligations/tuples.ts} +1 -1
  46. package/src/parallel-worker.ts +2 -18
  47. package/src/parallel.ts +10 -43
  48. package/src/prove/decide-pool.ts +100 -0
  49. package/src/prove/deciders.ts +27 -0
  50. package/src/prove/isabelle/LICENSE +36 -0
  51. package/src/prove/isabelle/LICENSE-tlapm +26 -0
  52. package/src/prove/isabelle/decide.ts +47 -0
  53. package/src/prove/isabelle/encode.ts +477 -0
  54. package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
  55. package/src/prove/isabelle/isar/method.ts +367 -0
  56. package/src/prove/isabelle/isar/proof.ts +28 -0
  57. package/src/prove/isabelle/isar/statement.ts +57 -0
  58. package/src/prove/isabelle/isar/theory.ts +192 -0
  59. package/src/prove/isabelle/isar/type-check.ts +278 -0
  60. package/src/prove/isabelle/provers/blast/blast.ts +258 -0
  61. package/src/prove/isabelle/provers/blast/branch.ts +322 -0
  62. package/src/prove/isabelle/provers/blast/prove.ts +347 -0
  63. package/src/prove/isabelle/provers/blast/rules.ts +330 -0
  64. package/src/prove/isabelle/provers/blast/state.ts +180 -0
  65. package/src/prove/isabelle/provers/blast/term.ts +547 -0
  66. package/src/prove/isabelle/provers/clasimp.ts +150 -0
  67. package/src/prove/isabelle/provers/classical.ts +389 -0
  68. package/src/prove/isabelle/provers/hypsubst.ts +441 -0
  69. package/src/prove/isabelle/pure/bicompose.ts +174 -0
  70. package/src/prove/isabelle/pure/consts.ts +32 -0
  71. package/src/prove/isabelle/pure/conv.ts +79 -0
  72. package/src/prove/isabelle/pure/drule.ts +264 -0
  73. package/src/prove/isabelle/pure/envir.ts +363 -0
  74. package/src/prove/isabelle/pure/goal.ts +53 -0
  75. package/src/prove/isabelle/pure/interrupt.ts +16 -0
  76. package/src/prove/isabelle/pure/list.ts +12 -0
  77. package/src/prove/isabelle/pure/logic.ts +402 -0
  78. package/src/prove/isabelle/pure/name.ts +110 -0
  79. package/src/prove/isabelle/pure/net.ts +262 -0
  80. package/src/prove/isabelle/pure/object-logic.ts +41 -0
  81. package/src/prove/isabelle/pure/pattern.ts +650 -0
  82. package/src/prove/isabelle/pure/raw-simplifier.ts +353 -0
  83. package/src/prove/isabelle/pure/rewriter.ts +602 -0
  84. package/src/prove/isabelle/pure/search.ts +68 -0
  85. package/src/prove/isabelle/pure/seq.ts +156 -0
  86. package/src/prove/isabelle/pure/simplifier.ts +112 -0
  87. package/src/prove/isabelle/pure/table.ts +208 -0
  88. package/src/prove/isabelle/pure/tactic.ts +276 -0
  89. package/src/prove/isabelle/pure/tactical.ts +347 -0
  90. package/src/prove/isabelle/pure/term-ord.ts +159 -0
  91. package/src/prove/isabelle/pure/term.ts +808 -0
  92. package/src/prove/isabelle/pure/thm.ts +806 -0
  93. package/src/prove/isabelle/pure/type.ts +133 -0
  94. package/src/prove/isabelle/pure/unify.ts +753 -0
  95. package/src/prove/isabelle/pure/variable.ts +25 -0
  96. package/src/prove/isabelle/tla/classical-setup.ts +101 -0
  97. package/src/prove/isabelle/tla/context.ts +74 -0
  98. package/src/prove/isabelle/tla/logic-data.ts +5 -0
  99. package/src/prove/isabelle/tla/logic.ts +215 -0
  100. package/src/prove/isabelle/tla/simpdata.ts +241 -0
  101. package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
  102. package/src/prove/ocaml.ts +22 -0
  103. package/src/prove/prep/action.ts +520 -0
  104. package/src/prove/prep/defs.ts +27 -0
  105. package/src/prove/prep/elab.ts +156 -0
  106. package/src/prove/prep/enabled-axioms.ts +189 -0
  107. package/src/prove/prep/enabled.ts +43 -0
  108. package/src/prove/prep/fingerprint.ts +388 -0
  109. package/src/prove/prep/flatten.ts +70 -0
  110. package/src/prove/prep/level-comparison.ts +552 -0
  111. package/src/prove/prep/md5.ts +67 -0
  112. package/src/prove/prep/pragma.ts +221 -0
  113. package/src/prove/prep/trivial.ts +22 -0
  114. package/src/prove/prove-worker.ts +29 -0
  115. package/src/prove/prove.ts +417 -0
  116. package/src/prove/ptl/decide.ts +68 -0
  117. package/src/prove/ptl/encode.ts +256 -0
  118. package/src/prove/ptl/sat.ts +151 -0
  119. package/src/prove/ptl/tableau.ts +276 -0
  120. package/src/prove/smt/axiomatize.ts +69 -0
  121. package/src/prove/smt/axioms.ts +210 -0
  122. package/src/prove/smt/context.ts +108 -0
  123. package/src/prove/smt/data.ts +665 -0
  124. package/src/prove/smt/encode.ts +169 -0
  125. package/src/prove/smt/extensionality.ts +63 -0
  126. package/src/prove/smt/flatten.ts +127 -0
  127. package/src/prove/smt/format.ts +143 -0
  128. package/src/prove/smt/instances.ts +182 -0
  129. package/src/prove/smt/rewrite.ts +784 -0
  130. package/src/prove/smt/simplify.ts +57 -0
  131. package/src/prove/smt/solver/act-cache.ts +265 -0
  132. package/src/prove/smt/solver/arith-rewriter.ts +962 -0
  133. package/src/prove/smt/solver/array.ts +22 -0
  134. package/src/prove/smt/solver/asserted-formulas.ts +469 -0
  135. package/src/prove/smt/solver/ast-lt.ts +157 -0
  136. package/src/prove/smt/solver/ast-util.ts +147 -0
  137. package/src/prove/smt/solver/ast.ts +1315 -0
  138. package/src/prove/smt/solver/auf-solver.ts +572 -0
  139. package/src/prove/smt/solver/case-split-queue.ts +178 -0
  140. package/src/prove/smt/solver/cg-table.ts +175 -0
  141. package/src/prove/smt/solver/clause.ts +276 -0
  142. package/src/prove/smt/solver/conflict-resolution.ts +343 -0
  143. package/src/prove/smt/solver/context.ts +1292 -0
  144. package/src/prove/smt/solver/ctx-simplify.ts +334 -0
  145. package/src/prove/smt/solver/der.ts +224 -0
  146. package/src/prove/smt/solver/dyn-ack.ts +141 -0
  147. package/src/prove/smt/solver/e-matching.ts +659 -0
  148. package/src/prove/smt/solver/enode.ts +259 -0
  149. package/src/prove/smt/solver/expr-ref.ts +21 -0
  150. package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
  151. package/src/prove/smt/solver/fingerprints.ts +92 -0
  152. package/src/prove/smt/solver/flat-literals.ts +51 -0
  153. package/src/prove/smt/solver/goal.ts +138 -0
  154. package/src/prove/smt/solver/hash.ts +173 -0
  155. package/src/prove/smt/solver/hashtable.ts +166 -0
  156. package/src/prove/smt/solver/internalizer.ts +1381 -0
  157. package/src/prove/smt/solver/lbool.ts +5 -0
  158. package/src/prove/smt/solver/literal.ts +24 -0
  159. package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
  160. package/src/prove/smt/solver/lp/constraints.ts +78 -0
  161. package/src/prove/smt/solver/lp/containers.ts +296 -0
  162. package/src/prove/smt/solver/lp/core-solver.ts +504 -0
  163. package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
  164. package/src/prove/smt/solver/lp/dep-intervals.ts +656 -0
  165. package/src/prove/smt/solver/lp/dependency.ts +51 -0
  166. package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
  167. package/src/prove/smt/solver/lp/explanation.ts +46 -0
  168. package/src/prove/smt/solver/lp/gomory.ts +255 -0
  169. package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
  170. package/src/prove/smt/solver/lp/hnf.ts +281 -0
  171. package/src/prove/smt/solver/lp/int-cube.ts +295 -0
  172. package/src/prove/smt/solver/lp/int-solver.ts +514 -0
  173. package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
  174. package/src/prove/smt/solver/lp/lar-term.ts +62 -0
  175. package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
  176. package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
  177. package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
  178. package/src/prove/smt/solver/lp/nex.ts +120 -0
  179. package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
  180. package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
  181. package/src/prove/smt/solver/lp/nla-core.ts +968 -0
  182. package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
  183. package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
  184. package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
  185. package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
  186. package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
  187. package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
  188. package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  189. package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
  190. package/src/prove/smt/solver/lp/nla-order.ts +307 -0
  191. package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
  192. package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
  193. package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
  194. package/src/prove/smt/solver/lp/nla-types.ts +124 -0
  195. package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
  196. package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
  197. package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
  198. package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
  199. package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
  200. package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
  201. package/src/prove/smt/solver/lp/pdd.ts +971 -0
  202. package/src/prove/smt/solver/lp/random-updater.ts +138 -0
  203. package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
  204. package/src/prove/smt/solver/lp/union-find.ts +96 -0
  205. package/src/prove/smt/solver/mam-compiler.ts +847 -0
  206. package/src/prove/smt/solver/mam-interpreter.ts +400 -0
  207. package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
  208. package/src/prove/smt/solver/model-checker.ts +347 -0
  209. package/src/prove/smt/solver/model-evaluator.ts +262 -0
  210. package/src/prove/smt/solver/model-finder.ts +155 -0
  211. package/src/prove/smt/solver/model-generator.ts +97 -0
  212. package/src/prove/smt/solver/model-macro-solver.ts +728 -0
  213. package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
  214. package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
  215. package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
  216. package/src/prove/smt/solver/nlsat/explain.ts +607 -0
  217. package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
  218. package/src/prove/smt/solver/nlsat/levelwise.ts +740 -0
  219. package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
  220. package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
  221. package/src/prove/smt/solver/nlsat/solver.ts +911 -0
  222. package/src/prove/smt/solver/nlsat/types.ts +43 -0
  223. package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  224. package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
  225. package/src/prove/smt/solver/nnf.ts +469 -0
  226. package/src/prove/smt/solver/pattern-inference.ts +351 -0
  227. package/src/prove/smt/solver/poly-rewriter.ts +477 -0
  228. package/src/prove/smt/solver/propagate-values.ts +83 -0
  229. package/src/prove/smt/solver/proto-model.ts +551 -0
  230. package/src/prove/smt/solver/pull-quant.ts +139 -0
  231. package/src/prove/smt/solver/qe-lite-der.ts +526 -0
  232. package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
  233. package/src/prove/smt/solver/qe-lite.ts +381 -0
  234. package/src/prove/smt/solver/qi-queue.ts +362 -0
  235. package/src/prove/smt/solver/quant-tactics.ts +117 -0
  236. package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
  237. package/src/prove/smt/solver/quantifier-manager.ts +186 -0
  238. package/src/prove/smt/solver/random-gen.ts +10 -0
  239. package/src/prove/smt/solver/rational.ts +165 -0
  240. package/src/prove/smt/solver/ref-vector.ts +62 -0
  241. package/src/prove/smt/solver/relevancy.ts +247 -0
  242. package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
  243. package/src/prove/smt/solver/rewriter.ts +843 -0
  244. package/src/prove/smt/solver/rlimit.ts +79 -0
  245. package/src/prove/smt/solver/smtlib-parser.ts +526 -0
  246. package/src/prove/smt/solver/solver.ts +71 -0
  247. package/src/prove/smt/solver/sort.ts +35 -0
  248. package/src/prove/smt/solver/sticky-generations.ts +69 -0
  249. package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
  250. package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
  251. package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
  252. package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
  253. package/src/prove/smt/solver/theory-lra-model.ts +243 -0
  254. package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
  255. package/src/prove/smt/solver/theory-lra-state.ts +43 -0
  256. package/src/prove/smt/solver/theory-lra.ts +56 -0
  257. package/src/prove/smt/solver/var-subst.ts +258 -0
  258. package/src/prove/smt/solver/z3-license.txt +10 -0
  259. package/src/prove/smt/table.ts +170 -0
  260. package/src/prove/tlapm/tlapm.ts +96 -0
  261. package/src/prove/tlaps-module.ts +510 -0
  262. package/src/prove/verdict.ts +13 -0
  263. package/src/prove/zenon/LICENSE +32 -0
  264. package/src/prove/zenon/check/check.ts +105 -0
  265. package/src/prove/zenon/check/definitions.ts +144 -0
  266. package/src/prove/zenon/check/equality.ts +182 -0
  267. package/src/prove/zenon/check/functions.ts +62 -0
  268. package/src/prove/zenon/check/keys.ts +125 -0
  269. package/src/prove/zenon/check/propositional.ts +104 -0
  270. package/src/prove/zenon/check/records.ts +188 -0
  271. package/src/prove/zenon/check/relations.ts +121 -0
  272. package/src/prove/zenon/check/rewrites.ts +224 -0
  273. package/src/prove/zenon/check/sets.ts +302 -0
  274. package/src/prove/zenon/check/terms.ts +127 -0
  275. package/src/prove/zenon/check/tla.ts +126 -0
  276. package/src/prove/zenon/decide.ts +113 -0
  277. package/src/prove/zenon/encode.ts +444 -0
  278. package/src/prove/zenon/eqrel.ts +300 -0
  279. package/src/prove/zenon/equality-rules.ts +435 -0
  280. package/src/prove/zenon/expr.ts +551 -0
  281. package/src/prove/zenon/index-table.ts +350 -0
  282. package/src/prove/zenon/isar-case.ts +513 -0
  283. package/src/prove/zenon/isar.ts +1249 -0
  284. package/src/prove/zenon/limits.ts +15 -0
  285. package/src/prove/zenon/llproof.ts +173 -0
  286. package/src/prove/zenon/mltoll.ts +1566 -0
  287. package/src/prove/zenon/node.ts +297 -0
  288. package/src/prove/zenon/ocaml.ts +169 -0
  289. package/src/prove/zenon/parse.ts +247 -0
  290. package/src/prove/zenon/phrase.ts +191 -0
  291. package/src/prove/zenon/proof.ts +198 -0
  292. package/src/prove/zenon/propositional-rules.ts +387 -0
  293. package/src/prove/zenon/rules.ts +94 -0
  294. package/src/prove/zenon/search.ts +288 -0
  295. package/src/prove/zenon/tla/functions.ts +151 -0
  296. package/src/prove/zenon/tla/llproof.ts +480 -0
  297. package/src/prove/zenon/tla/records.ts +225 -0
  298. package/src/prove/zenon/tla/rewrites.ts +447 -0
  299. package/src/prove/zenon/tla/sets.ts +304 -0
  300. package/src/prove/zenon/tla/terms.ts +181 -0
  301. package/src/prove/zenon/tla/tla.ts +506 -0
  302. package/src/run-cli.ts +73 -20
  303. package/src/standard-modules.ts +5 -2
  304. package/src/successors.ts +24 -5
  305. package/src/tlc-random.ts +55 -32
  306. package/src/tlc-version.ts +8 -7
  307. package/src/values.ts +85 -41
  308. package/src/worker.ts +65 -0
  309. package/dist/parallel.cjs +0 -12
  310. package/dist/parallel.js +0 -12
  311. /package/src/{obligation-format.ts → obligations/format.ts} +0 -0
@@ -0,0 +1,659 @@
1
+ // Ported from Z3 (src/smt/mam.cpp), MIT license, see z3-license.txt. Matching of quantifier
2
+ // patterns against the E-graph with Z3's matching abstract machine: the patterns are compiled into
3
+ // code trees, new relevant terms become candidates of the tree for their label, and the inverted
4
+ // path index with approximate label sets finds the candidates that a merge creates.
5
+ import { AstManager, KIND_VAR } from "./ast";
6
+ import type { Context } from "./context";
7
+ import type { Enode } from "./enode";
8
+ import { hashU, mkMix } from "./hash";
9
+ import { type CodeTree, Compiler, hasHash, type LabelHasher } from "./mam-compiler";
10
+ import { Interpreter, type OnMatch } from "./mam-interpreter";
11
+ import { setAt, shrink } from "./array";
12
+
13
+ // A step from a term to its parent: the parent's label, the position of the term in it, and an
14
+ // optional ground argument the parent must also have.
15
+ interface Path {
16
+ label: number;
17
+ argIndex: number;
18
+ groundArgIndex: number;
19
+ groundArg: Enode | null;
20
+ patternIndex: number;
21
+ child: Path | null;
22
+ }
23
+
24
+ // The inverted path index shares the prefixes of paths. Siblings are alternatives for the same step,
25
+ // the first child is the next step, and a code receives the terms where a path ends.
26
+ interface PathTree {
27
+ label: number;
28
+ argIndex: number;
29
+ groundArgIndex: number;
30
+ groundArg: Enode | null;
31
+ filter: number;
32
+ filterHigh: number;
33
+ code: CodeTree | null;
34
+ firstChild: PathTree | null;
35
+ sibling: PathTree | null;
36
+ // The roots that collect_parents visits at this node, while it walks the tree.
37
+ todo: Enode[] | null;
38
+ }
39
+
40
+ const isEqualPath = (first: Path, second: Path): boolean => {
41
+ let left = first;
42
+ let right = second;
43
+ for (;;) {
44
+ if (
45
+ left.label !== right.label ||
46
+ left.argIndex !== right.argIndex ||
47
+ left.patternIndex !== right.patternIndex ||
48
+ (left.child === null) !== (right.child === null)
49
+ )
50
+ return false;
51
+ if (left.child === null || right.child === null) return true;
52
+ left = left.child;
53
+ right = right.child;
54
+ }
55
+ };
56
+
57
+ // A multi-pattern of a quantifier: the terms of one of its patterns.
58
+ interface MultiPattern {
59
+ quantifier: number;
60
+ patterns: number[];
61
+ }
62
+
63
+ export class Mam implements LabelHasher {
64
+ private trees = new Map<number, CodeTree>();
65
+ // m_shared_enodes: the ground terms of the patterns.
66
+ private sharedEnodes = new Set<Enode>();
67
+ private toMatch: CodeTree[] = [];
68
+ private newPatterns: MultiPattern[] = [];
69
+ private pc = new Map<number, PathTree>();
70
+ private pp = new Map<number, (PathTree | null)[]>();
71
+ private plbls = new Set<number>();
72
+ private clbls = new Set<number>();
73
+ private r1: Enode | null = null;
74
+ private r2: Enode | null = null;
75
+ // The nodes that collect_parents marks, to unmark at the end of each level.
76
+ private visitedParents: Enode[] = [];
77
+ private queuedRoots: Enode[] = [];
78
+ private labelHashes: (number | undefined)[] = [];
79
+ // m_trail_stack: the matcher undoes its changes with a trail of its own, which the quantifier
80
+ // manager pops before the context pops its trail.
81
+ private trail: (() => void)[] = [];
82
+ private trailScopes: number[] = [];
83
+ private compiler: Compiler;
84
+ private interpreter: Interpreter;
85
+
86
+ constructor(
87
+ private context: Context,
88
+ onMatch: OnMatch,
89
+ ) {
90
+ this.compiler = new Compiler(context.manager, context, this);
91
+ this.interpreter = new Interpreter(context, onMatch);
92
+ }
93
+
94
+ private get manager(): AstManager {
95
+ return this.context.manager;
96
+ }
97
+
98
+ // label_hasher: Bob Jenkins' mix of the small id of a declaration, in [0, 64).
99
+ getLabelHash(decl: number) {
100
+ const cached = this.labelHashes[decl];
101
+ if (cached !== undefined) return cached;
102
+ const hash = mkMix(17, 3, this.manager.funcDecls[decl].smallId) & 63;
103
+ setAt(this.labelHashes, decl, hash);
104
+ return hash;
105
+ }
106
+
107
+ // enode::set_lbl_hash: a ground term of a pattern hashes its id, and its root's labels take it.
108
+ // The context's trail undoes both. Z3 pops it after the matcher's trail, so the labels of a root
109
+ // can keep a hash that a merge undone by the matcher's trail added.
110
+ private setLblHash(node: Enode) {
111
+ const hash = hashU(this.manager.ids[node.owner]) & 63;
112
+ node.lblHash = hash;
113
+ this.context.pushTrail(() => {
114
+ node.lblHash = -1;
115
+ });
116
+ const root = node.root;
117
+ if (hasHash(root.lbls, root.lblsHigh, hash)) return;
118
+ const low = root.lbls;
119
+ const high = root.lblsHigh;
120
+ this.context.pushTrail(() => {
121
+ root.lbls = low;
122
+ root.lblsHigh = high;
123
+ });
124
+ if (hash < 32) root.lbls |= 1 << hash;
125
+ else root.lblsHigh |= 1 << hash;
126
+ }
127
+
128
+ private pushTrail(undo: () => void) {
129
+ this.trail.push(undo);
130
+ }
131
+
132
+ getLblHash(node: Enode) {
133
+ if (node.lblHash === -1) this.setLblHash(node);
134
+ return node.lblHash;
135
+ }
136
+
137
+ hasWork() {
138
+ return this.toMatch.length > 0 || this.newPatterns.length > 0;
139
+ }
140
+
141
+ private updateLbls(node: Enode, hash: number) {
142
+ const root = node.root;
143
+ if (hasHash(root.lbls, root.lblsHigh, hash)) return;
144
+ const low = root.lbls;
145
+ const high = root.lblsHigh;
146
+ this.pushTrail(() => {
147
+ root.lbls = low;
148
+ root.lblsHigh = high;
149
+ });
150
+ if (hash < 32) root.lbls |= 1 << hash;
151
+ else root.lblsHigh |= 1 << hash;
152
+ }
153
+
154
+ private updateChildrenPlbls(node: Enode, hash: number) {
155
+ for (let index = 0; index < node.numArgs; index++) {
156
+ const root = node.getArg(index).root;
157
+ if (hasHash(root.plbls, root.plblsHigh, hash)) continue;
158
+ const low = root.plbls;
159
+ const high = root.plblsHigh;
160
+ this.pushTrail(() => {
161
+ root.plbls = low;
162
+ root.plblsHigh = high;
163
+ });
164
+ if (hash < 32) root.plbls |= 1 << hash;
165
+ else root.plblsHigh |= 1 << hash;
166
+ }
167
+ }
168
+
169
+ private updatePlbls(decl: number) {
170
+ if (this.plbls.has(decl)) return;
171
+ this.plbls.add(decl);
172
+ this.pushTrail(() => this.plbls.delete(decl));
173
+ const hash = this.getLabelHash(decl);
174
+ for (const node of this.context.enodesOf(decl))
175
+ if (this.context.isRelevant(node.owner)) this.updateChildrenPlbls(node, hash);
176
+ }
177
+
178
+ private updateClbls(decl: number) {
179
+ if (this.clbls.has(decl)) return;
180
+ this.clbls.add(decl);
181
+ this.pushTrail(() => this.clbls.delete(decl));
182
+ const hash = this.getLabelHash(decl);
183
+ for (const node of this.context.enodesOf(decl))
184
+ if (this.context.isRelevant(node.owner)) this.updateLbls(node, hash);
185
+ }
186
+
187
+ // mk_code: the code tree of a path, which runs each candidate once.
188
+ private mkCode(mp: MultiPattern, patternIndex: number) {
189
+ return this.compiler.mkTree(mp.quantifier, mp.patterns, patternIndex, true);
190
+ }
191
+
192
+ // mk_path_tree: a chain of path tree nodes whose last one has a code for the path's pattern.
193
+ private mkPathTree(path: Path, mp: MultiPattern): PathTree {
194
+ const tree: PathTree = {
195
+ label: path.label,
196
+ argIndex: path.argIndex,
197
+ groundArgIndex: path.groundArgIndex,
198
+ groundArg: path.groundArg,
199
+ filter: 0,
200
+ filterHigh: 0,
201
+ code: null,
202
+ firstChild: null,
203
+ sibling: null,
204
+ todo: null,
205
+ };
206
+ const hash = this.getLabelHash(path.label);
207
+ if (hash < 32) tree.filter = 1 << hash;
208
+ else tree.filterHigh = 1 << hash;
209
+ if (path.child === null) tree.code = this.mkCode(mp, path.patternIndex);
210
+ else tree.firstChild = this.mkPathTree(path.child, mp);
211
+ return tree;
212
+ }
213
+
214
+ // compiler::insert for path trees.
215
+ private insertPath(head: PathTree, path: Path, mp: MultiPattern) {
216
+ let isLabelFound = false;
217
+ let last = head;
218
+ for (let tree: PathTree | null = head; tree !== null; tree = tree.sibling) {
219
+ last = tree;
220
+ if (tree.label !== path.label) continue;
221
+ isLabelFound = true;
222
+ if (
223
+ tree.argIndex !== path.argIndex ||
224
+ tree.groundArg !== path.groundArg ||
225
+ tree.groundArgIndex !== path.groundArgIndex
226
+ )
227
+ continue;
228
+ const found = tree;
229
+ if (path.child !== null && found.firstChild !== null)
230
+ this.insertPath(found.firstChild, path.child, mp);
231
+ else if (path.child !== null) {
232
+ found.firstChild = this.mkPathTree(path.child, mp);
233
+ this.pushTrail(() => {
234
+ found.firstChild = null;
235
+ });
236
+ } else if (found.code !== null)
237
+ this.compiler.insert(found.code, mp.quantifier, mp.patterns, path.patternIndex, false);
238
+ else {
239
+ found.code = this.mkCode(mp, path.patternIndex);
240
+ this.pushTrail(() => {
241
+ found.code = null;
242
+ });
243
+ }
244
+ return;
245
+ }
246
+ const previous = last;
247
+ previous.sibling = this.mkPathTree(path, mp);
248
+ this.pushTrail(() => {
249
+ previous.sibling = null;
250
+ });
251
+ if (isLabelFound) return;
252
+ const low = head.filter;
253
+ const high = head.filterHigh;
254
+ this.pushTrail(() => {
255
+ head.filter = low;
256
+ head.filterHigh = high;
257
+ });
258
+ const hash = this.getLabelHash(path.label);
259
+ if (hash < 32) head.filter |= 1 << hash;
260
+ else head.filterHigh |= 1 << hash;
261
+ }
262
+
263
+ private updatePc(firstHash: number, secondHash: number, path: Path, mp: MultiPattern) {
264
+ const key = firstHash * 64 + secondHash;
265
+ const existing = this.pc.get(key);
266
+ if (existing !== undefined) {
267
+ this.insertPath(existing, path, mp);
268
+ return;
269
+ }
270
+ this.pc.set(key, this.mkPathTree(path, mp));
271
+ this.pushTrail(() => this.pc.delete(key));
272
+ }
273
+
274
+ private insertPpPath(entry: (PathTree | null)[], index: number, path: Path, mp: MultiPattern) {
275
+ const existing = entry[index];
276
+ if (existing !== null) {
277
+ this.insertPath(existing, path, mp);
278
+ return;
279
+ }
280
+ entry[index] = this.mkPathTree(path, mp);
281
+ this.pushTrail(() => {
282
+ entry[index] = null;
283
+ });
284
+ }
285
+
286
+ private updatePp(
287
+ inputFirstHash: number,
288
+ inputSecondHash: number,
289
+ inputFirst: Path,
290
+ inputSecond: Path,
291
+ mp: MultiPattern,
292
+ ) {
293
+ const isSwapped = inputFirstHash > inputSecondHash;
294
+ const firstHash = isSwapped ? inputSecondHash : inputFirstHash;
295
+ const secondHash = isSwapped ? inputFirstHash : inputSecondHash;
296
+ const first = isSwapped ? inputSecond : inputFirst;
297
+ const second = isSwapped ? inputFirst : inputSecond;
298
+ const key = firstHash * 64 + secondHash;
299
+ let entry = this.pp.get(key);
300
+ if (entry === undefined) {
301
+ entry = [null, null];
302
+ this.pp.set(key, entry);
303
+ this.pushTrail(() => this.pp.delete(key));
304
+ }
305
+ if (firstHash === secondHash) {
306
+ this.insertPpPath(entry, 0, first, mp);
307
+ if (!isEqualPath(first, second)) this.insertPpPath(entry, 0, second, mp);
308
+ return;
309
+ }
310
+ this.insertPpPath(entry, 0, first, mp);
311
+ this.insertPpPath(entry, 1, second, mp);
312
+ }
313
+
314
+ getGroundEnode(expr: number, quantifier: number) {
315
+ const context = this.context;
316
+ if (!context.isEInternalized(expr))
317
+ context.internalize(expr, false, context.qmanager.getGeneration(quantifier));
318
+ return context.getEnode(expr) ?? null;
319
+ }
320
+
321
+ private updateFilters(
322
+ pattern: number,
323
+ parentPath: Path | null,
324
+ patternIndex: number,
325
+ varPaths: Path[][],
326
+ mp: MultiPattern,
327
+ ) {
328
+ const manager = this.manager;
329
+ const numArgs = manager.getNumArgs(pattern);
330
+ let groundArgIndex = -1;
331
+ for (let index = 0; index < numArgs && groundArgIndex === -1; index++)
332
+ if (manager.isGround(manager.getArg(pattern, index))) groundArgIndex = index;
333
+ const groundArg =
334
+ groundArgIndex === -1
335
+ ? null
336
+ : this.getGroundEnode(manager.getArg(pattern, groundArgIndex), mp.quantifier);
337
+ const label = manager.decls[pattern];
338
+ for (let index = 0; index < numArgs; index++) {
339
+ const child = manager.getArg(pattern, index);
340
+ const path: Path = {
341
+ label,
342
+ argIndex: index,
343
+ groundArgIndex: groundArgIndex === -1 ? 0 : groundArgIndex,
344
+ groundArg,
345
+ patternIndex,
346
+ child: parentPath,
347
+ };
348
+ if (manager.kinds[child] === KIND_VAR) {
349
+ const paths = varPaths[manager.values[child]];
350
+ let isFound = false;
351
+ for (const existing of paths) {
352
+ if (isEqualPath(path, existing)) isFound = true;
353
+ this.updatePlbls(existing.label);
354
+ this.updatePlbls(path.label);
355
+ this.updatePp(
356
+ this.getLabelHash(existing.label),
357
+ this.getLabelHash(path.label),
358
+ existing,
359
+ path,
360
+ mp,
361
+ );
362
+ }
363
+ if (!isFound) paths.push(path);
364
+ continue;
365
+ }
366
+ if (manager.isGround(child)) {
367
+ const node = this.getGroundEnode(child, mp.quantifier);
368
+ if (node === null) continue;
369
+ this.updatePlbls(label);
370
+ this.updatePc(this.getLabelHash(label), this.getLblHash(node), path, mp);
371
+ continue;
372
+ }
373
+ const childLabel = manager.decls[child];
374
+ this.updatePlbls(label);
375
+ this.updateClbls(childLabel);
376
+ this.updatePc(this.getLabelHash(label), this.getLabelHash(childLabel), path, mp);
377
+ this.updateFilters(child, path, patternIndex, varPaths, mp);
378
+ }
379
+ }
380
+
381
+ addPattern(quantifier: number, patterns: number[]) {
382
+ const manager = this.manager;
383
+ if (patterns.every((pattern) => manager.isGround(pattern))) return;
384
+ if (patterns.some((pattern) => manager.hasQuantifierFlags[pattern])) return;
385
+ const mp = { quantifier, patterns };
386
+ const numDecls = manager.getQuantifier(quantifier).sorts.length;
387
+ const varPaths: Path[][] = Array.from({ length: numDecls }, () => []);
388
+ patterns.forEach((pattern, index) => this.updateFilters(pattern, null, index, varPaths, mp));
389
+ this.collectGroundExprs(quantifier, patterns);
390
+ this.newPatterns.push(mp);
391
+ // code_tree_map::add_pattern for each pattern as the first one.
392
+ patterns.forEach((pattern, firstIndex) => {
393
+ if (manager.isGround(pattern)) return;
394
+ const label = manager.decls[pattern];
395
+ const tree = this.trees.get(label);
396
+ if (tree !== undefined) {
397
+ if (tree.numArgs === manager.getNumArgs(pattern))
398
+ this.compiler.insert(tree, quantifier, patterns, firstIndex, false);
399
+ return;
400
+ }
401
+ this.trees.set(label, this.compiler.mkTree(quantifier, patterns, firstIndex, false));
402
+ this.pushTrail(() => this.trees.delete(label));
403
+ });
404
+ }
405
+
406
+ // collect_ground_exprs: the ground patterns become relevant enodes, and the ground subterms of the
407
+ // other patterns become enodes that theory combination treats as shared.
408
+ private collectGroundExprs(quantifier: number, patterns: number[]) {
409
+ const manager = this.manager;
410
+ const todo: number[] = [];
411
+ for (const pattern of patterns) {
412
+ if (!manager.isGround(pattern)) {
413
+ todo.push(pattern);
414
+ continue;
415
+ }
416
+ const node = this.getGroundEnode(pattern, quantifier);
417
+ if (node === null) continue;
418
+ this.context.markAsRelevant(node.owner);
419
+ this.addSharedEnode(node);
420
+ }
421
+ for (let term = todo.pop(); term !== undefined; term = todo.pop()) {
422
+ if (manager.isGround(term)) {
423
+ const node = this.getGroundEnode(term, quantifier);
424
+ if (node !== null) this.addSharedEnode(node);
425
+ } else
426
+ for (let index = 0; index < manager.getNumArgs(term); index++) {
427
+ const arg = manager.getArg(term, index);
428
+ if (manager.kinds[arg] !== KIND_VAR) todo.push(arg);
429
+ }
430
+ }
431
+ }
432
+
433
+ private addSharedEnode(node: Enode) {
434
+ if (this.sharedEnodes.has(node)) return;
435
+ this.sharedEnodes.add(node);
436
+ this.context.pushTrail(() => this.sharedEnodes.delete(node));
437
+ }
438
+
439
+ isShared(node: Enode) {
440
+ return this.sharedEnodes.has(node);
441
+ }
442
+
443
+ // add_candidate, with compress_candidates, which keeps the first of each candidate once there are
444
+ // many, as match does.
445
+ private addCandidateTo(tree: CodeTree, node: Enode) {
446
+ if (tree.candidates.length === 0) this.toMatch.push(tree);
447
+ tree.candidates.push(node);
448
+ if (tree.candidates.length < tree.candidateGcThreshold) return;
449
+ tree.candidates = [...new Set(tree.candidates)];
450
+ if (2 * tree.candidates.length > tree.candidateGcThreshold) tree.candidateGcThreshold *= 2;
451
+ }
452
+
453
+ relevantEh(node: Enode, isLazy: boolean) {
454
+ if (node.lblHash !== -1) this.updateLbls(node, node.lblHash);
455
+ if (node.numArgs === 0) return;
456
+ const hash = this.getLabelHash(node.decl);
457
+ if (this.clbls.has(node.decl)) this.updateLbls(node, hash);
458
+ if (this.plbls.has(node.decl)) this.updateChildrenPlbls(node, hash);
459
+ const tree = this.trees.get(node.decl);
460
+ if (!isLazy && tree !== undefined) this.addCandidateTo(tree, node);
461
+ }
462
+
463
+ private isEqModMerge(first: Enode, second: Enode) {
464
+ const firstRoot = first.root;
465
+ const secondRoot = second.root;
466
+ return (
467
+ firstRoot === secondRoot ||
468
+ (firstRoot === this.r1 && secondRoot === this.r2) ||
469
+ (firstRoot === this.r2 && secondRoot === this.r1)
470
+ );
471
+ }
472
+
473
+ // collect_parents: walks the path tree level by level from the merged class, visiting each parent
474
+ // once per level, and hands the terms where a path ends to that path's code. The mark of a parent
475
+ // says it was visited at this level, and the second mark of a root says it is queued for the next.
476
+ private collectParents(start: Enode, head: PathTree | null | undefined) {
477
+ if (head === null || head === undefined) return;
478
+ const context = this.context;
479
+ const levels: PathTree[] = [head];
480
+ const visitedParents = this.visitedParents;
481
+ const queuedRoots = this.queuedRoots;
482
+ head.todo = [start];
483
+ for (let index = 0; index < levels.length; index++) {
484
+ const level = levels[index];
485
+ const nodes = level.todo ?? [];
486
+ level.todo = null;
487
+ const filter = level.filter;
488
+ const filterHigh = level.filterHigh;
489
+ for (const node of nodes) {
490
+ const child = node.root;
491
+ if ((child.plbls & filter) === 0 && (child.plblsHigh & filterHigh) === 0) continue;
492
+ for (const parent of child.parents) {
493
+ if (parent.isEq) continue;
494
+ const label = parent.decl;
495
+ const parentRoot = parent.root;
496
+ if (
497
+ !hasHash(filter, filterHigh, this.getLabelHash(label)) ||
498
+ parent.isMarked ||
499
+ (parent.cg !== parent && this.isEqModMerge(parent.cg, parentRoot)) ||
500
+ !context.isRelevant(parent.owner)
501
+ )
502
+ continue;
503
+ for (let tree: PathTree | null = level; tree !== null; tree = tree.sibling) {
504
+ if (
505
+ tree.label !== label ||
506
+ tree.argIndex >= parent.numArgs ||
507
+ parent.getArg(tree.argIndex).root !== child ||
508
+ (tree.groundArg !== null &&
509
+ !this.isEqModMerge(tree.groundArg, parent.getArg(tree.groundArgIndex)))
510
+ )
511
+ continue;
512
+ if (tree.code !== null) this.addCandidateTo(tree.code, parent);
513
+ const next = tree.firstChild;
514
+ if (next === null) continue;
515
+ if (next.todo === null) {
516
+ next.todo = [];
517
+ levels.push(next);
518
+ }
519
+ if (!parentRoot.isMarked2) next.todo.push(parentRoot);
520
+ }
521
+ parent.isMarked = true;
522
+ visitedParents.push(parent);
523
+ if (!parentRoot.isMarked2) {
524
+ parentRoot.isMarked2 = true;
525
+ queuedRoots.push(parentRoot);
526
+ }
527
+ }
528
+ }
529
+ for (const parent of visitedParents) parent.isMarked = false;
530
+ for (const root of queuedRoots) root.isMarked2 = false;
531
+ visitedParents.length = 0;
532
+ queuedRoots.length = 0;
533
+ }
534
+ }
535
+
536
+ private processPc(r1: Enode, r2: Enode) {
537
+ if ((r1.plbls === 0 && r1.plblsHigh === 0) || (r2.lbls === 0 && r2.lblsHigh === 0)) return;
538
+ for (let parentHash = 0; parentHash < 64; parentHash++) {
539
+ if (!hasHash(r1.plbls, r1.plblsHigh, parentHash)) continue;
540
+ if (this.context.checkCanceled()) return;
541
+ for (let childHash = 0; childHash < 64; childHash++)
542
+ if (hasHash(r2.lbls, r2.lblsHigh, childHash))
543
+ this.collectParents(r1, this.pc.get(parentHash * 64 + childHash));
544
+ }
545
+ }
546
+
547
+ private processPp(r1: Enode, r2: Enode) {
548
+ if ((r1.plbls === 0 && r1.plblsHigh === 0) || (r2.plbls === 0 && r2.plblsHigh === 0)) return;
549
+ for (let firstHash = 0; firstHash < 64; firstHash++) {
550
+ if (!hasHash(r1.plbls, r1.plblsHigh, firstHash)) continue;
551
+ if (this.context.checkCanceled()) return;
552
+ for (let secondHash = 0; secondHash < 64; secondHash++) {
553
+ if (!hasHash(r2.plbls, r2.plblsHigh, secondHash)) continue;
554
+ const isSwapped = firstHash > secondHash;
555
+ const lowHash = isSwapped ? secondHash : firstHash;
556
+ const highHash = isSwapped ? firstHash : secondHash;
557
+ const lowRoot = isSwapped ? r2 : r1;
558
+ const highRoot = isSwapped ? r1 : r2;
559
+ const entry = this.pp.get(lowHash * 64 + highHash);
560
+ if (entry === undefined) continue;
561
+ if (lowHash === highHash) {
562
+ if (lowRoot.parents.length <= highRoot.parents.length)
563
+ this.collectParents(lowRoot, entry[0]);
564
+ else this.collectParents(highRoot, entry[0]);
565
+ } else if (lowRoot.parents.length <= highRoot.parents.length)
566
+ this.collectParents(lowRoot, entry[0]);
567
+ else this.collectParents(highRoot, entry[1]);
568
+ }
569
+ }
570
+ }
571
+
572
+ // add_eq_eh: r2's labels take r1's after the paths are followed.
573
+ addEqEh(r1: Enode, r2: Enode) {
574
+ this.r1 = r1;
575
+ this.r2 = r2;
576
+ this.processPc(r1, r2);
577
+ this.processPc(r2, r1);
578
+ this.processPp(r1, r2);
579
+ this.r1 = null;
580
+ this.r2 = null;
581
+ const lbls = r2.lbls;
582
+ const lblsHigh = r2.lblsHigh;
583
+ const plbls = r2.plbls;
584
+ const plblsHigh = r2.plblsHigh;
585
+ this.pushTrail(() => {
586
+ r2.lbls = lbls;
587
+ r2.lblsHigh = lblsHigh;
588
+ r2.plbls = plbls;
589
+ r2.plblsHigh = plblsHigh;
590
+ });
591
+ r2.lbls |= r1.lbls;
592
+ r2.lblsHigh |= r1.lblsHigh;
593
+ r2.plbls |= r1.plbls;
594
+ r2.plblsHigh |= r1.plblsHigh;
595
+ }
596
+
597
+ match() {
598
+ for (const tree of this.toMatch) {
599
+ if (!this.interpreter.execute(tree)) return;
600
+ tree.candidates = [];
601
+ }
602
+ this.toMatch = [];
603
+ if (this.newPatterns.length > 0) this.matchNewPatterns();
604
+ }
605
+
606
+ // match_new_patterns: one temporary tree per label, in the order the labels first appear, run
607
+ // against the relevant terms with the label.
608
+ private matchNewPatterns() {
609
+ const context = this.context;
610
+ const manager = this.manager;
611
+ const tmpTrees = new Map<number, CodeTree>();
612
+ for (const mp of this.newPatterns) {
613
+ if (context.checkCanceled()) break;
614
+ const label = manager.decls[mp.patterns[0]];
615
+ if (context.enodesOf(label).length === 0) continue;
616
+ const tree = tmpTrees.get(label);
617
+ if (tree === undefined)
618
+ tmpTrees.set(label, this.compiler.mkTree(mp.quantifier, mp.patterns, 0, false));
619
+ else this.compiler.insert(tree, mp.quantifier, mp.patterns, 0, true);
620
+ }
621
+ for (const entry of tmpTrees) {
622
+ const nodes = context.enodesOf(entry[0]);
623
+ for (let index = 0; index < nodes.length; index++)
624
+ if (context.isRelevant(nodes[index].owner))
625
+ this.interpreter.executeCore(entry[1], nodes[index]);
626
+ }
627
+ this.newPatterns = [];
628
+ }
629
+
630
+ // rematch: every code tree, in the order of their labels' small ids, against every relevant term.
631
+ rematch() {
632
+ const context = this.context;
633
+ const funcDecls = this.manager.funcDecls;
634
+ const entries = [...this.trees].sort(
635
+ (left, right) => funcDecls[left[0]].smallId - funcDecls[right[0]].smallId,
636
+ );
637
+ for (const entry of entries) {
638
+ const tree = entry[1];
639
+ const nodes = context.enodesOf(entry[0]);
640
+ for (let index = 0; index < nodes.length; index++)
641
+ if (context.isRelevant(nodes[index].owner))
642
+ this.interpreter.executeCore(tree, nodes[index]);
643
+ }
644
+ }
645
+
646
+ pushScope() {
647
+ this.trailScopes.push(this.trail.length);
648
+ }
649
+
650
+ popScope(numScopes: number) {
651
+ for (const tree of this.toMatch) tree.candidates = [];
652
+ this.toMatch = [];
653
+ this.newPatterns = [];
654
+ const limit = this.trailScopes[this.trailScopes.length - numScopes];
655
+ for (let index = this.trail.length - 1; index >= limit; index--) this.trail[index]();
656
+ shrink(this.trail, limit);
657
+ shrink(this.trailScopes, this.trailScopes.length - numScopes);
658
+ }
659
+ }