tla-ts 0.0.10-dev.d618a2d79 → 0.0.10-dev.e5c8dc315

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 (263) hide show
  1. package/dist/compile.cjs +3 -3
  2. package/dist/compile.js +1 -1
  3. package/dist/deciders.cjs +36 -36
  4. package/dist/deciders.js +53 -53
  5. package/dist/index.cjs +1 -1
  6. package/dist/index.d.cts +18 -4
  7. package/dist/index.d.ts +18 -4
  8. package/dist/index.js +1 -1
  9. package/dist/parallel-worker.cjs +1 -1
  10. package/dist/parallel-worker.js +1 -1
  11. package/dist/prove-worker.cjs +1 -1
  12. package/dist/prove-worker.js +1 -1
  13. package/dist/prove.cjs +56 -56
  14. package/dist/prove.js +78 -78
  15. package/dist/run.cjs +40 -44
  16. package/dist/run.js +42 -46
  17. package/dist/tlapm.cjs +1 -1
  18. package/dist/tlapm.js +2 -2
  19. package/dist/transfer.cjs +97 -92
  20. package/dist/transfer.js +97 -92
  21. package/dist/worker.cjs +7 -7
  22. package/dist/worker.js +7 -7
  23. package/package.json +1 -1
  24. package/src/ast.ts +31 -3
  25. package/src/bags.ts +50 -29
  26. package/src/builtins.ts +4 -3
  27. package/src/check-failure.ts +13 -11
  28. package/src/check-trace.ts +146 -93
  29. package/src/check.ts +518 -281
  30. package/src/cli/runtime-invariants.ts +20 -56
  31. package/src/cli/tlc-arguments.ts +2 -2
  32. package/src/cli/tlc-output.ts +18 -4
  33. package/src/cli/tlc.ts +18 -12
  34. package/src/cli/xml-exporter.ts +1 -1
  35. package/src/codegen.ts +23 -10
  36. package/src/coverage.ts +255 -18
  37. package/src/dependencies.ts +68 -15
  38. package/src/dfid.ts +101 -36
  39. package/src/environment.ts +155 -66
  40. package/src/errors.ts +7 -0
  41. package/src/evaluate.ts +424 -135
  42. package/src/exit-codes.ts +28 -14
  43. package/src/instances.ts +152 -25
  44. package/src/java-hash.ts +14 -0
  45. package/src/java-overrides.ts +2 -2
  46. package/src/levels.ts +675 -236
  47. package/src/lexer.ts +12 -2
  48. package/src/liveness-checker.ts +179 -60
  49. package/src/liveness.ts +55 -10
  50. package/src/obligations/index.ts +1 -1
  51. package/src/obligations/normalize.ts +1 -4
  52. package/src/obligations/printer.ts +5 -5
  53. package/src/obligations/source.ts +2 -0
  54. package/src/parallel-worker.ts +8 -2
  55. package/src/parallel.ts +5 -0
  56. package/src/parser.ts +180 -149
  57. package/src/prover/isabelle/isar/attrib.ts +4 -4
  58. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  59. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  60. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  61. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  62. package/src/prover/isabelle/pure/term.ts +3 -3
  63. package/src/prover/prep/md5.ts +26 -29
  64. package/src/prover/smt/rewrite.ts +2 -7
  65. package/src/prover/smt/simplify.ts +1 -1
  66. package/src/prover/smt/solver/ackermannize-bv-tactic.ts +3 -2
  67. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  68. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  69. package/src/prover/smt/solver/asserted-formulas.ts +171 -58
  70. package/src/prover/smt/solver/ast-lt.ts +1 -1
  71. package/src/prover/smt/solver/ast.ts +66 -14
  72. package/src/prover/smt/solver/auf-solver.ts +23 -12
  73. package/src/prover/smt/solver/bit-blast-tactic.ts +28 -2
  74. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  75. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  76. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  77. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  78. package/src/prover/smt/solver/bv1-blast.ts +1 -1
  79. package/src/prover/smt/solver/card2bv.ts +35 -18
  80. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  81. package/src/prover/smt/solver/context.ts +84 -15
  82. package/src/prover/smt/solver/ctx-simplify.ts +9 -4
  83. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  84. package/src/prover/smt/solver/dependent-expr-state.ts +28 -16
  85. package/src/prover/smt/solver/diff-neq.ts +9 -8
  86. package/src/prover/smt/solver/dt2bv-tactic.ts +66 -28
  87. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  88. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  89. package/src/prover/smt/solver/elim-uncnstr.ts +31 -28
  90. package/src/prover/smt/solver/eq2bv-tactic.ts +15 -6
  91. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  92. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  93. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  94. package/src/prover/smt/solver/euf/egraph.ts +4 -11
  95. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  96. package/src/prover/smt/solver/euf/mam.ts +1 -5
  97. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  98. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  99. package/src/prover/smt/solver/expr2polynomial.ts +204 -79
  100. package/src/prover/smt/solver/factor.ts +36 -14
  101. package/src/prover/smt/solver/fd-solver.ts +608 -139
  102. package/src/prover/smt/solver/fix-dl-var.ts +2 -3
  103. package/src/prover/smt/solver/fm-tactic.ts +9 -7
  104. package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
  105. package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
  106. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  107. package/src/prover/smt/solver/fpa2bv-tactic.ts +1 -1
  108. package/src/prover/smt/solver/goal.ts +6 -3
  109. package/src/prover/smt/solver/goal2nlsat.ts +57 -30
  110. package/src/prover/smt/solver/hashtable.ts +4 -0
  111. package/src/prover/smt/solver/internalizer.ts +1 -1
  112. package/src/prover/smt/solver/lia2pb.ts +1 -1
  113. package/src/prover/smt/solver/logic-tactics.ts +15 -5
  114. package/src/prover/smt/solver/lp/core-solver.ts +12 -8
  115. package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
  116. package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
  117. package/src/prover/smt/solver/lp/nla-core.ts +1 -1
  118. package/src/prover/smt/solver/lp/nla-grobner.ts +158 -80
  119. package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
  120. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
  121. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
  122. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
  123. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  124. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  125. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  126. package/src/prover/smt/solver/maxcore.ts +2 -1
  127. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  128. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  129. package/src/prover/smt/solver/model-checker.ts +1 -1
  130. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  131. package/src/prover/smt/solver/model-generator.ts +85 -43
  132. package/src/prover/smt/solver/mpf.ts +2 -4
  133. package/src/prover/smt/solver/mus.ts +2 -3
  134. package/src/prover/smt/solver/muz/dl-context.ts +22 -44
  135. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  136. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  137. package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
  138. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  139. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  140. package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
  141. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  142. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  143. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  144. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  145. package/src/prover/smt/solver/nlqsat.ts +2 -1
  146. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  147. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  148. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  149. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  150. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  151. package/src/prover/smt/solver/nlsat/solver.ts +74 -64
  152. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  153. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  154. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  155. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  156. package/src/prover/smt/solver/nnf.ts +6 -2
  157. package/src/prover/smt/solver/normalize-bounds.ts +2 -2
  158. package/src/prover/smt/solver/occf.ts +1 -1
  159. package/src/prover/smt/solver/opt-context.ts +21 -7
  160. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  161. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  162. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  163. package/src/prover/smt/solver/opt-solver.ts +10 -6
  164. package/src/prover/smt/solver/optsmt.ts +1 -1
  165. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  166. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  167. package/src/prover/smt/solver/pb2bv-tactic.ts +9 -3
  168. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  169. package/src/prover/smt/solver/probes.ts +88 -23
  170. package/src/prover/smt/solver/proto-model.ts +8 -8
  171. package/src/prover/smt/solver/purify-arith.ts +51 -49
  172. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  173. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  174. package/src/prover/smt/solver/qe-lite.ts +2 -2
  175. package/src/prover/smt/solver/qe.ts +3 -2
  176. package/src/prover/smt/solver/qsat.ts +23 -8
  177. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  178. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  179. package/src/prover/smt/solver/reduce-args.ts +2 -2
  180. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  181. package/src/prover/smt/solver/rewriter.ts +31 -25
  182. package/src/prover/smt/solver/rlimit.ts +7 -3
  183. package/src/prover/smt/solver/sat/config.ts +1 -1
  184. package/src/prover/smt/solver/sat/goal2sat.ts +75 -12
  185. package/src/prover/smt/solver/sat/inc-sat-solver.ts +149 -47
  186. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  187. package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
  188. package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
  189. package/src/prover/smt/solver/sat/sat-tactic.ts +54 -25
  190. package/src/prover/smt/solver/sat/sat2goal.ts +75 -50
  191. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  192. package/src/prover/smt/solver/sat/solver.ts +27 -47
  193. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  194. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  195. package/src/prover/smt/solver/seq-derive.ts +2 -2
  196. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  197. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  198. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  199. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  200. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  201. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  202. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  203. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  204. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  205. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  206. package/src/prover/smt/solver/smt-kernel.ts +48 -7
  207. package/src/prover/smt/solver/smt-setup.ts +106 -13
  208. package/src/prover/smt/solver/smtlib-parser.ts +589 -224
  209. package/src/prover/smt/solver/smtlib-script.ts +718 -213
  210. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  211. package/src/prover/smt/solver/solver.ts +18 -4
  212. package/src/prover/smt/solver/tactic.ts +389 -199
  213. package/src/prover/smt/solver/theory-bv.ts +13 -3
  214. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  215. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  216. package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
  217. package/src/prover/smt/solver/theory-lra-propagate.ts +12 -3
  218. package/src/prover/smt/solver/theory-lra-state.ts +1 -1
  219. package/src/prover/smt/solver/theory-lra.ts +1 -1
  220. package/src/prover/smt/solver/theory-pb.ts +24 -7
  221. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  222. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  223. package/src/prover/smt/solver/theory-without-terms.ts +24 -0
  224. package/src/prover/smt/solver/tseitin-cnf.ts +15 -5
  225. package/src/prover/tlapm/cache.ts +8 -8
  226. package/src/prover/zenon/index-table.ts +5 -2
  227. package/src/prover/zenon/isar-case.ts +1 -1
  228. package/src/prover/zenon/isar.ts +2 -2
  229. package/src/prover/zenon/phrase.ts +1 -1
  230. package/src/resolve.ts +1311 -268
  231. package/src/runtime.ts +21 -2
  232. package/src/sany/builtins.ts +10 -10
  233. package/src/sany/generation.ts +5 -15
  234. package/src/sany/generator-def-entries.ts +123 -36
  235. package/src/sany/generator-definitions.ts +5 -3
  236. package/src/sany/generator-expressions.ts +60 -37
  237. package/src/sany/generator-proofs.ts +19 -12
  238. package/src/sany/generator.ts +12 -6
  239. package/src/sany/lexer.ts +15 -7
  240. package/src/sany/modules.ts +4 -2
  241. package/src/sany/nodes.ts +1 -1
  242. package/src/sany/selectors.ts +12 -6
  243. package/src/sany/xml.ts +2 -3
  244. package/src/search.ts +321 -135
  245. package/src/simulate.ts +247 -185
  246. package/src/spec-description.ts +15 -7
  247. package/src/standard-definitions.ts +1 -0
  248. package/src/standard-modules.ts +56 -22
  249. package/src/subexpressions.ts +666 -147
  250. package/src/successors.ts +50 -20
  251. package/src/symmetry.ts +2 -1
  252. package/src/tlc/jar-data.ts +10 -0
  253. package/src/tlc/messages.ts +3 -3
  254. package/src/tlc/order.ts +14 -3
  255. package/src/tlc/random.ts +2 -1
  256. package/src/tlc/replay.ts +147 -46
  257. package/src/tlc/tlc-operators.ts +10 -8
  258. package/src/tlc/tlcext-operators.ts +44 -15
  259. package/src/tlc/trace-spec.ts +9 -22
  260. package/src/trace-liveness.ts +529 -0
  261. package/src/typed-tier.ts +52 -31
  262. package/src/typescript/types.ts +2 -2
  263. package/src/values.ts +150 -79
package/src/evaluate.ts CHANGED
@@ -1,5 +1,6 @@
1
1
  import {
2
2
  getChildren,
3
+ getFunctionConstruction,
3
4
  getReferencedName,
4
5
  isLocallyResolved,
5
6
  type Bound,
@@ -22,13 +23,27 @@ import {
22
23
  } from "./errors";
23
24
  import { EXIT_STATUS, setExitCode } from "./exit-codes";
24
25
  import { generateEvaluator } from "./codegen";
25
- import { countCoverage, getCoverageNode, runAtCoverageNode, type Coverage } from "./coverage";
26
+ import {
27
+ chargeContexts,
28
+ chargeFunctionConstruction,
29
+ chargeSetOperation,
30
+ costCoverage,
31
+ countCoverage,
32
+ createChargedEnumerator,
33
+ createProductSetEnumerator,
34
+ getCoverageNode,
35
+ runAtCoverageNode,
36
+ tagSubset,
37
+ type Coverage,
38
+ } from "./coverage";
26
39
  import { MESSAGE_CODE } from "./tlc/messages";
27
40
  import type { CheckerRuntime } from "./runtime";
28
41
  import {
29
- isConstantLevel,
42
+ isEvaluatedAtStartup,
43
+ isExpressionImpure,
30
44
  isImpureDefinition,
31
45
  isNonconstant,
46
+ isTlcEvalReached,
32
47
  type DefinitionFacts,
33
48
  } from "./dependencies";
34
49
  import { contextualApplications, substitutionFrames } from "./instances";
@@ -152,6 +167,7 @@ export interface Environment {
152
167
  variableIndex: Map<string, number>;
153
168
  facts: DefinitionFacts;
154
169
  startupValues: (Value | undefined)[];
170
+ tlcEvalValues: WeakMap<Expression, Value>;
155
171
  substitutedDefinitions: Set<Definition>;
156
172
  instanceParams: Set<OperatorParam>;
157
173
  evaluators: WeakMap<Expression, Evaluator>;
@@ -320,15 +336,14 @@ export const getDomainOperator = (expression: Expression) => (value: Value) => {
320
336
  };
321
337
 
322
338
  export const getSubsetOperator =
323
- (expression: Expression, builtin: Builtin) => (left: Value, right: Value) => {
339
+ (expression: Expression, subset: (left: Value, right: Value) => Value) =>
340
+ (left: Value, right: Value) => {
324
341
  if (!isSetValue(left) || isOverriddenSet(left)) {
325
342
  throw new TlaEvaluationError(
326
343
  `Attempted to evaluate an expression of form S \\subseteq T, but S was not enumerable.\n${describeRange(expression)}`,
327
344
  );
328
345
  }
329
- return builtin.evaluateBinary
330
- ? builtin.evaluateBinary(left, right)
331
- : builtin.evaluate([left, right]);
346
+ return subset(left, right);
332
347
  };
333
348
 
334
349
  export const createRealNumberError = (expression: DecimalExpression) =>
@@ -523,10 +538,13 @@ const someElement = (
523
538
  return false;
524
539
  };
525
540
 
526
- export const mapBoundSets = <Result>(bounds: Bound[], map: (set: Expression) => Result) =>
541
+ export const mapBoundSets = <Result>(
542
+ bounds: Bound[],
543
+ map: (set: Expression, index: number) => Result,
544
+ ) =>
527
545
  bounds.reduce<Result[]>((results, bound, index) => {
528
546
  results.push(
529
- index > 0 && bounds[index - 1].set === bound.set ? results[index - 1] : map(bound.set),
547
+ index > 0 && bounds[index - 1].set === bound.set ? results[index - 1] : map(bound.set, index),
530
548
  );
531
549
  return results;
532
550
  }, []);
@@ -557,6 +575,31 @@ export const forEachBinding = (
557
575
  visit: (scope: Scope | undefined) => boolean,
558
576
  ) => forEachBoundElement(bounds, getBoundElements(bounds, context), context.scope, visit);
559
577
 
578
+ const forEachChargedBinding = (
579
+ bounds: Bound[],
580
+ context: Context,
581
+ coverage: Coverage,
582
+ visit: (scope: Scope | undefined) => boolean,
583
+ ) => {
584
+ const bounded = mapBoundSets(bounds, (set) => {
585
+ const value = evaluate(set, context);
586
+ return {
587
+ value,
588
+ elements: getQuantifierElements(value, set, context.environment.runtime.version),
589
+ };
590
+ });
591
+ const sets = bounded.map((item) => item.elements);
592
+ const charge = chargeContexts(
593
+ coverage,
594
+ bounded.map((item) => item.value),
595
+ sets,
596
+ );
597
+ return forEachBoundElement(bounds, sets, context.scope, (scope) => {
598
+ charge();
599
+ return visit(scope);
600
+ });
601
+ };
602
+
560
603
  const getBoundsDomain = (bounds: Bound[], context: Context): Value => {
561
604
  const sets = mapBoundSets(bounds, (set) => evaluate(set, context));
562
605
  return sets.length === 1 ? sets[0] : { kind: "ProductSet", factors: sets };
@@ -615,12 +658,16 @@ export const bindLazyArguments = (
615
658
  typeof value.domain === "object" && value.domain.kind === "ProductSet"
616
659
  ? value.domain.factors
617
660
  : [];
618
- // Deviation from TLC: FcnLambdaValue#apply indexes past an argument tuple shorter than the bounds and ignores a longer one.
661
+ if (elements === undefined) {
662
+ throw new TlaEvaluationError(
663
+ `Attempted to apply a function to an argument not in its domain.\n${describeRange(expression.function)}`,
664
+ );
665
+ }
666
+ // Deviation from TLC: Tool#getFcnContext indexes past an argument tuple shorter than the bounds and ignores a longer one.
619
667
  const createListError = () =>
620
668
  new TlaEvaluationError(
621
669
  `In applying the function\n${prettyPrint(formatValue(value))},\nthe argument list is:\n${prettyPrint(formatValue(argument))}\nwhich does not match its formal parameter.\n`,
622
670
  );
623
- if (elements === undefined) throw createListError();
624
671
  bounds.forEach((bound, index) => {
625
672
  if (index >= elements.length) throw createListError();
626
673
  const element = elements[index];
@@ -669,7 +716,7 @@ const getLazyFunctionTemplate = (bounds: Bound[], body: Expression) => {
669
716
  },
670
717
  ],
671
718
  ),
672
- body: formatRange(range),
719
+ body: describeNode(body),
673
720
  };
674
721
  };
675
722
 
@@ -715,28 +762,29 @@ const getBoundTupleLengths = (bounds: Bound[]) =>
715
762
  bound.pattern.kind === "Tuple" ? bound.pattern.names.length : undefined,
716
763
  );
717
764
 
718
- const getDefinitionSource = (definition: FunctionDefinition): Expression => ({
719
- kind: "FunctionConstruction",
720
- bounds: definition.bounds,
721
- body: definition.body,
722
- location: definition.location,
723
- });
724
-
725
765
  const createRecursiveFunction = (
726
766
  definition: FunctionDefinition,
727
767
  context: Context,
728
768
  ): RebindableLazyFunction => {
729
769
  const domain = getBoundsDomain(definition.bounds, context);
770
+ const compute = (argument: Value, self: Value) =>
771
+ evaluate(
772
+ definition.body,
773
+ withScope(
774
+ context,
775
+ bindArgument(definition.bounds, bindValue(undefined, definition.name, self), argument),
776
+ ),
777
+ );
778
+ const coverage = context.environment.coverage;
779
+ const node = coverage && !context.environment.callStack ? coverage.current : -1;
730
780
  const functionValue = createLazyFunction(
731
781
  domain,
732
- (argument, self) =>
733
- evaluate(
734
- definition.body,
735
- withScope(
736
- context,
737
- bindArgument(definition.bounds, bindValue(undefined, definition.name, self), argument),
738
- ),
739
- ),
782
+ coverage
783
+ ? (argument, self) =>
784
+ coverage.current === -1
785
+ ? compute(argument, self)
786
+ : runAtCoverageNode(coverage, node, () => compute(argument, self))
787
+ : compute,
740
788
  getLazyFunctionSource(
741
789
  getLazyFunctionTemplate(definition.bounds, definition.body),
742
790
  definition.bounds,
@@ -788,9 +836,17 @@ const compileDefinitionBody = (definition: Definition, environment: Environment)
788
836
  };
789
837
  }
790
838
  if (definition.kind !== "Function") return getEntryEvaluator(definition.body, environment);
791
- if (definition.isSelfReferential)
792
- return (context) => createRecursiveFunction(definition, context);
793
- return getEntryEvaluator(getDefinitionSource(definition), environment);
839
+ const construction = getFunctionConstruction(definition, false);
840
+ if (!definition.isSelfReferential) return getEntryEvaluator(construction, environment);
841
+ const evaluator: Evaluator = (context) => createRecursiveFunction(definition, context);
842
+ const coverage = environment.coverage;
843
+ return coverage ? countEvaluator(construction, evaluator, coverage) : evaluator;
844
+ };
845
+
846
+ const CALLER_SCOPE: Scope = {
847
+ name: "",
848
+ binding: { kind: "Value", value: false },
849
+ parent: undefined,
794
850
  };
795
851
 
796
852
  const getDefinitionEvaluator = (definition: Definition, environment: Environment): Evaluator => {
@@ -799,8 +855,15 @@ const getDefinitionEvaluator = (definition: Definition, environment: Environment
799
855
  const body = compileDefinitionBody(definition, environment);
800
856
  const definitionId = environment.facts.ids.get(definition);
801
857
  const startupValues = environment.startupValues;
802
- const evaluator: Evaluator =
803
- definitionId === undefined
858
+ const isInCallerContext =
859
+ definition.kind === "Operator" &&
860
+ definition.params.length === 0 &&
861
+ isTlcEvalReached(definition.body, environment);
862
+ const evaluator: Evaluator = isInCallerContext
863
+ ? (context) =>
864
+ (definitionId === undefined ? undefined : startupValues[definitionId]) ??
865
+ body(withScope(context, isTlcContextEmpty(context.scope) ? undefined : CALLER_SCOPE))
866
+ : definitionId === undefined
804
867
  ? (context) => body(withScope(context, undefined))
805
868
  : (context) => startupValues[definitionId] ?? body(withScope(context, undefined));
806
869
  environment.definitionEvaluators.set(definition, evaluator);
@@ -817,7 +880,7 @@ export const evaluateStartupDefinitions = (definitions: Definition[], environmen
817
880
  if (definition.kind === "Operator" && definition.params.length > 0) return;
818
881
  const name = definition.name;
819
882
  if (environment.constants.has(name) || environment.substitutions.has(name)) return;
820
- if (!isConstantLevel(definition, environment)) return;
883
+ if (!isEvaluatedAtStartup(definition, environment)) return;
821
884
  const definitionId = environment.facts.ids.get(definition);
822
885
  if (definitionId === undefined || environment.startupValues[definitionId] !== undefined) return;
823
886
  const context = { environment, scope: undefined, state: undefined, next: undefined };
@@ -969,6 +1032,7 @@ const isOperatorArgument = (expression: Expression, context: Context) => {
969
1032
  return operator !== undefined && getArity(operator) > 0;
970
1033
  };
971
1034
 
1035
+ // Deviation from TLC: SymbolNodeValueLookupProvider#lookup takes an operator whose body is a literal for that literal, so a Java override rejects it as an argument.
972
1036
  const evaluateBuiltinArguments = (args: Expression[], context: Context) =>
973
1037
  args.map((arg) =>
974
1038
  isOperatorArgument(arg, context)
@@ -1083,20 +1147,29 @@ interface ReevaluatedDefinitions {
1083
1147
  streamed: ReadonlySet<Definition>;
1084
1148
  }
1085
1149
 
1086
- const letFunctionConstructions = new WeakMap<FunctionDefinition, Expression>();
1150
+ const isRecursiveOperator = (definition: Definition) =>
1151
+ definition.kind === "Operator" && definition.isRecursive && definition.params.length > 0;
1087
1152
 
1088
- const getLetFunctionConstruction = (definition: FunctionDefinition): Expression => {
1089
- const known = letFunctionConstructions.get(definition);
1090
- if (known) return known;
1091
- const construction: Expression = {
1092
- kind: "FunctionConstruction",
1093
- bounds: definition.bounds,
1094
- body: definition.body,
1095
- location: definition.location,
1096
- isRecursive: true,
1097
- };
1098
- letFunctionConstructions.set(definition, construction);
1099
- return construction;
1153
+ // TLC finds a RECURSIVE operator with parameters by its definition, not in its context, so every definition reaches it.
1154
+ const chainRecursiveOperatorsFirst = (
1155
+ definitions: Definition[],
1156
+ nodes: Scope[],
1157
+ outer: Scope | undefined,
1158
+ ) => {
1159
+ let scope = outer;
1160
+ for (let index = 0; index < definitions.length; index++) {
1161
+ if (isRecursiveOperator(definitions[index])) {
1162
+ nodes[index].parent = scope;
1163
+ scope = nodes[index];
1164
+ }
1165
+ }
1166
+ for (let index = 0; index < definitions.length; index++) {
1167
+ if (!isRecursiveOperator(definitions[index])) {
1168
+ nodes[index].parent = scope;
1169
+ scope = nodes[index];
1170
+ }
1171
+ }
1172
+ return scope;
1100
1173
  };
1101
1174
 
1102
1175
  export const bindDefinitions = (
@@ -1109,16 +1182,29 @@ export const bindDefinitions = (
1109
1182
  binding: { kind: "Value", value: false },
1110
1183
  parent: undefined,
1111
1184
  }));
1112
- const scope = nodes.reduce<Scope | undefined>((parent, node) => {
1113
- node.parent = parent;
1114
- return node;
1115
- }, context.scope);
1116
- definitions.forEach((definition, index) => {
1185
+ let scope = context.scope;
1186
+ let hasRecursive = false;
1187
+ for (let index = 0; index < nodes.length; index++) {
1188
+ nodes[index].parent = scope;
1189
+ scope = nodes[index];
1190
+ hasRecursive ||= definitions[index].isRecursive;
1191
+ }
1192
+ if (hasRecursive) scope = chainRecursiveOperatorsFirst(definitions, nodes, context.scope);
1193
+ let isRecursiveValueAtOrAfter = false;
1194
+ for (let index = definitions.length - 1; index >= 0; index--) {
1195
+ const definition = definitions[index];
1196
+ isRecursiveValueAtOrAfter ||=
1197
+ definition.isRecursive && definition.kind === "Operator" && definition.params.length === 0;
1198
+ // TLC's LET evaluates an operator without parameters in the context before it, which TLCEval#tlcEval tells from an empty one.
1199
+ const ownScope =
1200
+ definition.kind === "Operator" && definition.params.length === 0 && !isRecursiveValueAtOrAfter
1201
+ ? nodes[index].parent
1202
+ : scope;
1117
1203
  nodes[index].binding =
1118
1204
  definition.kind === "Function"
1119
1205
  ? {
1120
1206
  kind: "Thunk",
1121
- expression: getLetFunctionConstruction(definition),
1207
+ expression: getFunctionConstruction(definition, true),
1122
1208
  scope,
1123
1209
  state: context.state,
1124
1210
  next: context.next,
@@ -1133,19 +1219,19 @@ export const bindDefinitions = (
1133
1219
  name: definition.name,
1134
1220
  params: definition.params,
1135
1221
  body: definition.body,
1136
- scope,
1222
+ scope: ownScope,
1137
1223
  },
1138
1224
  }
1139
1225
  : {
1140
1226
  kind: "Thunk",
1141
1227
  expression: definition.body,
1142
- scope,
1228
+ scope: ownScope,
1143
1229
  state: context.state,
1144
1230
  next: context.next,
1145
1231
  cache: undefined,
1146
1232
  isStreamed: reevaluated?.streamed.has(definition) ?? false,
1147
1233
  };
1148
- });
1234
+ }
1149
1235
  const coverage = context.environment.coverage;
1150
1236
  if (coverage && coverage.current !== -1) {
1151
1237
  nodes.forEach((node) => {
@@ -1175,16 +1261,22 @@ const evaluateLocalIdentifier = (name: string, expression: Expression, context:
1175
1261
  if (global?.kind === "Definition") {
1176
1262
  return getDefinitionEvaluator(global.definition, context.environment)(context);
1177
1263
  }
1178
- const builtin = context.environment.builtins.get(name);
1264
+ const builtin = context.environment.builtins.get(
1265
+ context.environment.substitutions.get(name) ?? name,
1266
+ );
1179
1267
  if (builtin?.arity === 0) return builtin.evaluate([], context);
1180
- throw new TlaEvaluationError(`Unknown identifier ${name} at ${describeLocation(expression)}`);
1268
+ throw new TlaEvaluationError(
1269
+ `In evaluation, the identifier ${name} is either undefined or not an operator.\n${describeRange(expression)}`,
1270
+ );
1181
1271
  };
1182
1272
 
1183
1273
  export const getReevaluatedDefinitions = (
1184
1274
  definitions: Definition[],
1185
1275
  environment: Environment,
1186
1276
  ): ReevaluatedDefinitions => ({
1187
- impure: new Set(definitions.filter((definition) => isImpureDefinition(definition, environment))),
1277
+ impure: new Set(
1278
+ definitions.filter((definition) => isImpureDefinition(definition, environment, "varying")),
1279
+ ),
1188
1280
  streamed: new Set(
1189
1281
  definitions.filter((definition) => isImpureDefinition(definition, environment, "streamed")),
1190
1282
  ),
@@ -1316,7 +1408,6 @@ const headFingerprint = (callStack: CallStack, source: Expression, error: unknow
1316
1408
 
1317
1409
  export const createTracingEnvironment = (environment: Environment): Environment => ({
1318
1410
  ...environment,
1319
- coverage: undefined,
1320
1411
  evaluators: new WeakMap(),
1321
1412
  entryEvaluators: new WeakMap(),
1322
1413
  definitionEvaluators: new WeakMap(),
@@ -1329,6 +1420,41 @@ export const createTracingEnvironment = (environment: Environment): Environment
1329
1420
  },
1330
1421
  });
1331
1422
 
1423
+ // TLC evaluates `a /\ b /\ c` as `(a /\ b) /\ c`, so its call stack holds each prefix.
1424
+ const compileTracedJunction = (
1425
+ expression: Expression & { kind: "And" | "Or" },
1426
+ operands: Evaluator[],
1427
+ callStack: CallStack | undefined,
1428
+ ): Evaluator | undefined => {
1429
+ const range = expression.location.range;
1430
+ const prefixEnds = expression.prefixEnds;
1431
+ if (!callStack || expression.isBulleted || !range || !prefixEnds || operands.length < 3) {
1432
+ return undefined;
1433
+ }
1434
+ const prefixes = prefixEnds
1435
+ .slice(0, operands.length - 2)
1436
+ .map((end) => ({
1437
+ ...expression,
1438
+ location: { ...expression.location, range: { ...range, end } },
1439
+ }))
1440
+ .reverse();
1441
+ const isAnd = expression.kind === "And";
1442
+ return (context) => {
1443
+ callStack.expressions.push(...prefixes);
1444
+ for (let index = 0; index < operands.length; index++) {
1445
+ if (index >= 2 && !callStack.isFrozen) callStack.expressions.pop();
1446
+ const value = operands[index](context);
1447
+ if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
1448
+ if (value !== isAnd) {
1449
+ if (!callStack.isFrozen)
1450
+ callStack.expressions.length -= prefixes.length - Math.max(index - 1, 0);
1451
+ return value;
1452
+ }
1453
+ }
1454
+ return isAnd;
1455
+ };
1456
+ };
1457
+
1332
1458
  const traceFrames =
1333
1459
  (
1334
1460
  expression: Expression,
@@ -1356,9 +1482,21 @@ const countEvaluator =
1356
1482
  coverage.current = node;
1357
1483
  try {
1358
1484
  const value = evaluator(context);
1359
- if (typeof value === "object" && expression.kind === "SetEnumeration") {
1360
- coverage.values.set(value, node);
1361
- }
1485
+ const isTagged =
1486
+ expression.kind === "SetEnumeration" ||
1487
+ ((expression.kind === "SetFilter" || expression.kind === "SetMap") &&
1488
+ isReducibleSet(value)) ||
1489
+ (expression.kind === "SetFilter" &&
1490
+ typeof value === "object" &&
1491
+ value.kind === "FilteredSet") ||
1492
+ ((expression.kind === "FunctionSet" || expression.kind === "RecordSet") &&
1493
+ typeof value === "object" &&
1494
+ value.kind === expression.kind) ||
1495
+ (expression.kind === "Apply" &&
1496
+ expression.operator === "SUBSET" &&
1497
+ typeof value === "object" &&
1498
+ value.kind === "Subset");
1499
+ if (typeof value === "object" && isTagged) coverage.values.set(value, node);
1362
1500
  return value;
1363
1501
  } finally {
1364
1502
  coverage.current = outer;
@@ -1508,6 +1646,26 @@ const compileClosureCall = (
1508
1646
  };
1509
1647
  };
1510
1648
 
1649
+ // TLC's LET conses only its arity-0 definitions onto the context that TLCEval#tlcEval caches under when it is empty.
1650
+ const isTlcContextEmpty = (scope: Scope | undefined) => {
1651
+ for (let node = scope; node !== undefined; node = node.parent) {
1652
+ const binding = node.binding;
1653
+ if (
1654
+ binding.kind !== "Operator" ||
1655
+ binding.operator.kind !== "Closure" ||
1656
+ binding.operator.params.length === 0
1657
+ ) {
1658
+ return false;
1659
+ }
1660
+ let letScope = binding.operator.scope;
1661
+ while (letScope !== undefined && letScope !== node) letScope = letScope.parent;
1662
+ if (letScope !== node) return false;
1663
+ }
1664
+ return true;
1665
+ };
1666
+
1667
+ const SET_OPERATORS = new Set(["\\cup", "\\cap", "\\"]);
1668
+
1511
1669
  const compileApply = (
1512
1670
  expression: Expression & { kind: "Apply" },
1513
1671
  environment: Environment,
@@ -1547,19 +1705,63 @@ const compileApply = (
1547
1705
  return (context) => domain(operand(context));
1548
1706
  }
1549
1707
  if (global?.kind === "Builtin" && global.name === "TLCEval" && args.length === 1) {
1708
+ // Deviation from TLC: TLCEval#tlcEval evaluates an argument SANY takes for constant, such as Print(v, TRUE), in an empty state.
1550
1709
  const isCached =
1551
1710
  !contextualApplications.has(expression) && !isNonconstant(args[0], environment);
1552
- return (context) =>
1553
- global.evaluate(
1554
- getLazyArguments(args, context),
1555
- isCached && context.scope === undefined ? undefined : context,
1556
- );
1711
+ const tlcEvalValues = environment.tlcEvalValues;
1712
+ return (context) => {
1713
+ if (!isCached || !isTlcContextEmpty(context.scope)) {
1714
+ return global.evaluate(getLazyArguments(args, context), context);
1715
+ }
1716
+ const cached = tlcEvalValues.get(expression);
1717
+ if (cached !== undefined) return cached;
1718
+ const value = global.evaluate(getLazyArguments(args, context), undefined);
1719
+ tlcEvalValues.set(expression, value);
1720
+ return value;
1721
+ };
1722
+ }
1723
+ if (
1724
+ global?.kind === "Builtin" &&
1725
+ global.name === "\\subseteq" &&
1726
+ global.evaluateBinary &&
1727
+ args.length === 2
1728
+ ) {
1729
+ const left = getEvaluator(args[0], environment);
1730
+ const right = getEvaluator(args[1], environment);
1731
+ const subset = getSubsetOperator(expression, global.evaluateBinary);
1732
+ const coverage = environment.coverage;
1733
+ if (!coverage) return (context) => subset(left(context), right(context));
1734
+ return (context) => {
1735
+ const leftValue = left(context);
1736
+ const rightValue = right(context);
1737
+ if (
1738
+ typeof leftValue !== "object" ||
1739
+ leftValue.kind !== "Set" ||
1740
+ !coverage.values.has(leftValue)
1741
+ ) {
1742
+ return subset(leftValue, rightValue);
1743
+ }
1744
+ const missing = leftValue.elements.findIndex((element) => !isElementOf(element, rightValue));
1745
+ costCoverage(coverage, leftValue, (missing === -1 ? leftValue.elements.length : missing) + 1);
1746
+ return missing === -1;
1747
+ };
1557
1748
  }
1558
- if (global?.kind === "Builtin" && global.name === "\\subseteq" && args.length === 2) {
1749
+ const coverage = environment.coverage;
1750
+ const combine = global?.kind === "Builtin" ? global.evaluateBinary : undefined;
1751
+ if (coverage && combine && SET_OPERATORS.has(expression.operator) && args.length === 2) {
1559
1752
  const left = getEvaluator(args[0], environment);
1560
1753
  const right = getEvaluator(args[1], environment);
1561
- const subset = getSubsetOperator(expression, global);
1562
- return (context) => subset(left(context), right(context));
1754
+ return (context) => {
1755
+ const leftValue = left(context);
1756
+ const rightValue = right(context);
1757
+ return chargeSetOperation(
1758
+ coverage,
1759
+ expression.operator,
1760
+ leftValue,
1761
+ rightValue,
1762
+ combine(leftValue, rightValue),
1763
+ );
1764
+ };
1563
1765
  }
1564
1766
  if (global?.kind === "Builtin") return compileBuiltinCall(global, args, environment);
1565
1767
  if (expression.operator === "\\cdot" && args.length === 2) {
@@ -1592,6 +1794,18 @@ const compileQuantifier = (
1592
1794
  const isForall = expression.kind === "Forall";
1593
1795
  const body = getEvaluator(expression.body, environment);
1594
1796
  const bound = expression.bounds[0];
1797
+ const coverage = environment.coverage;
1798
+ if (coverage) {
1799
+ return (context) => {
1800
+ const isFound = forEachChargedBinding(
1801
+ expression.bounds,
1802
+ context,
1803
+ coverage,
1804
+ (scope) => expectBooleanBody(body(withScope(context, scope)), expression) !== isForall,
1805
+ );
1806
+ return isFound ? !isForall : isForall;
1807
+ };
1808
+ }
1595
1809
  if (expression.bounds.length === 1 && bound.pattern.kind === "Name") {
1596
1810
  const name = bound.pattern.name;
1597
1811
  const set = getEvaluator(bound.set, environment);
@@ -1717,8 +1931,14 @@ export const getFunctionBuilder = (
1717
1931
  return markLambdaFunction(functionValue);
1718
1932
  }
1719
1933
  const pairs: [Value, Value][] = [];
1720
- const sets = mapBoundSets(bounds, (set) =>
1721
- getNormalizedElements(evaluate(set, context), set, context.environment.runtime.version),
1934
+ const sets = mapBoundSets(bounds, (set, index) =>
1935
+ getNormalizedElements(
1936
+ bounds.length > 1 && typeof domain === "object" && domain.kind === "ProductSet"
1937
+ ? domain.factors[index]
1938
+ : domain,
1939
+ set,
1940
+ context.environment.runtime.version,
1941
+ ),
1722
1942
  );
1723
1943
  forEachBoundElement(bounds, sets, context.scope, (scope) => {
1724
1944
  const key =
@@ -1733,13 +1953,22 @@ export const getFunctionBuilder = (
1733
1953
  const template = getLazyFunctionTemplate(bounds, expression.body);
1734
1954
  const boundTupleLengths = getBoundTupleLengths(bounds);
1735
1955
  const bodyNames = getScopeNames(expression.body);
1956
+ const coverage = environment.coverage;
1736
1957
  const createLazy = (domain: Value, context: Context) => {
1737
1958
  const scope = trimScope(context.scope, bodyNames);
1738
1959
  const lambdaContext = withScope(context, scope);
1960
+ const compute = (argument: Value) =>
1961
+ body(withScope(lambdaContext, bindArgument(bounds, scope, argument)));
1962
+ const node = coverage && !environment.callStack ? coverage.current : -1;
1739
1963
  const functionValue = keepLambda({
1740
1964
  value: createLazyFunction(
1741
1965
  domain,
1742
- (argument) => body(withScope(lambdaContext, bindArgument(bounds, scope, argument))),
1966
+ coverage
1967
+ ? (argument) =>
1968
+ coverage.current === -1
1969
+ ? compute(argument)
1970
+ : runAtCoverageNode(coverage, node, () => compute(argument))
1971
+ : compute,
1743
1972
  getLazyFunctionSource(template, bounds, domain),
1744
1973
  boundTupleLengths,
1745
1974
  ),
@@ -1791,6 +2020,23 @@ const compileFunctionConstruction = (
1791
2020
  ): Evaluator => {
1792
2021
  const build = getFunctionBuilder(expression, environment).build;
1793
2022
  const bounds = expression.bounds;
2023
+ const coverage = environment.coverage;
2024
+ if (coverage) {
2025
+ return (context) => {
2026
+ const domain = getBoundsDomain(bounds, context);
2027
+ const value = build(domain, context);
2028
+ const sets =
2029
+ bounds.length === 1 || typeof domain !== "object" || domain.kind !== "ProductSet"
2030
+ ? [domain]
2031
+ : domain.factors;
2032
+ const isConverted =
2033
+ (typeof value !== "object" || value.kind !== "LazyFunction") && sets.every(isReducibleSet);
2034
+ if (isConverted && coverage.current !== -1 && coverage.covered.has(expression)) {
2035
+ chargeFunctionConstruction(coverage, coverage.current, sets);
2036
+ }
2037
+ return value;
2038
+ };
2039
+ }
1794
2040
  if (bounds.length === 1 && bounds[0].pattern.kind === "Name") {
1795
2041
  const set = getEvaluator(bounds[0].set, environment);
1796
2042
  return (context) => build(set(context), context);
@@ -1864,29 +2110,19 @@ export const getLazyFilter = (
1864
2110
  ) => {
1865
2111
  const predicate = getEvaluator(expression.predicate, environment);
1866
2112
  const pattern = expression.bound.pattern;
1867
- const range = expression.predicate.location.range;
1868
- const source = range && {
2113
+ const predicateNode = describeNode(expression.predicate);
2114
+ const source = expression.predicate.location.range && {
1869
2115
  names: pattern.kind === "Name" ? pattern.name : pattern.names.join(", "),
1870
- predicate: formatRange(range),
2116
+ predicate: predicateNode,
1871
2117
  };
1872
- const predicateNode = describeNode(expression.predicate);
1873
2118
  const coverage = environment.coverage;
1874
- const testCovered = (node: number, isMember: boolean, test: () => Value) => {
1875
- if (!coverage || node === -1) return test();
1876
- if (!isMember) coverage.secondary[node]++;
1877
- const value = runAtCoverageNode(coverage, isMember ? -1 : node, test);
1878
- if (!isMember && value === true) coverage.secondary[node]++;
1879
- return value;
1880
- };
1881
2119
  const createFiltered = (
1882
2120
  base: Value,
1883
2121
  context: Context,
1884
2122
  evaluator: Evaluator,
1885
2123
  node: number,
1886
- ): RebindableFilteredSet => ({
1887
- kind: "FilteredSet",
1888
- base,
1889
- test: (element, isMember) => {
2124
+ ): RebindableFilteredSet => {
2125
+ const test = (element: Value, isMember: boolean) => {
1890
2126
  if (
1891
2127
  pattern.kind === "Tuple" &&
1892
2128
  getSequenceElements(element)?.length !== pattern.names.length
@@ -1895,29 +2131,60 @@ export const getLazyFilter = (
1895
2131
  `Attempted to check if the value:\n${prettyPrint(formatValue(element))}\nis an element of a set of ${pattern.names.length}-tuples.`,
1896
2132
  );
1897
2133
  }
1898
- const value = testCovered(node, isMember, () =>
1899
- evaluator(withScope(context, bindPattern(context.scope, pattern, element))),
1900
- );
2134
+ const value = evaluator(withScope(context, bindPattern(context.scope, pattern, element)));
1901
2135
  if (typeof value !== "boolean") {
1902
2136
  throw new TlaEvaluationError(
1903
2137
  `${isMember ? "The evaluation of predicate" : "Evaluating predicate"} ${predicateNode} yielded non-Boolean value.`,
1904
2138
  );
1905
2139
  }
1906
2140
  return value;
1907
- },
1908
- source,
1909
- rebind: (tracing) =>
2141
+ };
2142
+ const rebind = (tracing: Environment) =>
1910
2143
  createFiltered(
1911
2144
  base,
1912
2145
  { ...context, environment: tracing },
1913
2146
  getEvaluator(expression.predicate, tracing),
1914
2147
  -1,
1915
- ),
1916
- });
2148
+ );
2149
+ if (!coverage || node === -1) return { kind: "FilteredSet", base, test, source, rebind };
2150
+ return {
2151
+ kind: "FilteredSet",
2152
+ base,
2153
+ test: (element, isMember) =>
2154
+ runAtCoverageNode(coverage, isMember ? -1 : node, () => test(element, isMember)),
2155
+ startPass: (isMaterialized) => {
2156
+ const draws = createProductSetEnumerator(coverage, base);
2157
+ return (element) => {
2158
+ draws?.next();
2159
+ tagSubset(coverage, base, element);
2160
+ coverage.secondary[node]++;
2161
+ const value = runAtCoverageNode(coverage, node, () => test(element, false));
2162
+ if (isMaterialized && value) coverage.secondary[node]++;
2163
+ return value;
2164
+ };
2165
+ },
2166
+ source,
2167
+ rebind,
2168
+ };
2169
+ };
1917
2170
  return (base: Value, context: Context, node = -1) =>
1918
2171
  createFiltered(base, context, predicate, node);
1919
2172
  };
1920
2173
 
2174
+ const hasLocalName = (expression: Expression): boolean =>
2175
+ isLocallyResolved(expression) ||
2176
+ expression.kind === "OperatorReference" ||
2177
+ getChildren(expression).some(hasLocalName);
2178
+
2179
+ export const isUniformPredicate = (
2180
+ expression: Expression & { kind: "SetFilter" },
2181
+ environment: Environment,
2182
+ ) =>
2183
+ expression.bound.pattern.kind === "Name" &&
2184
+ !environment.coverage &&
2185
+ !hasLocalName(expression.predicate) &&
2186
+ !isExpressionImpure([expression.predicate], environment, "varying");
2187
+
1921
2188
  export const expectFilterPredicate = (
1922
2189
  value: Value,
1923
2190
  expression: Expression & { kind: "SetFilter" },
@@ -1960,32 +2227,34 @@ const compileSetComprehension = (
1960
2227
  const filterLazily = getLazyFilter(expression, environment);
1961
2228
  const pattern = expression.bound.pattern;
1962
2229
  const coverage = environment.coverage;
2230
+ const isUniform = isUniformPredicate(expression, environment);
1963
2231
  return (context) => {
1964
2232
  const base = set(context);
1965
2233
  if (!isReducibleSet(base)) return filterLazily(base, context, coverage?.current);
1966
2234
  const kept: Value[] = [];
1967
- const visit = (element: Value) => {
2235
+ const elements = base.kind === "Interval" ? base : toFiniteSet(base).elements;
2236
+ const size = Array.isArray(elements) ? elements.length : elements.high - elements.low + 1;
2237
+ for (let position = 0; position < size; position++) {
2238
+ const element = Array.isArray(elements) ? elements[position] : elements.low + position;
1968
2239
  const value = predicate(withScope(context, bindPattern(context.scope, pattern, element)));
1969
2240
  if (expectFilterPredicate(value, expression)) addBoundedElement(kept, element);
1970
- };
1971
- const elements = base.kind === "Interval" ? base : toFiniteSet(base).elements;
1972
- forEachElement(elements, visit);
1973
- if (coverage && coverage.current !== -1) {
1974
- coverage.secondary[coverage.current] +=
1975
- (Array.isArray(elements) ? elements.length : elements.high - elements.low + 1) +
1976
- kept.length;
2241
+ else if (isUniform) break;
1977
2242
  }
2243
+ if (coverage) costCoverage(coverage, base, size + 1);
1978
2244
  return createNormalizedSet(kept);
1979
2245
  };
1980
2246
  }
1981
2247
  if (expression.kind === "SetMap") {
1982
2248
  const mapped = getEvaluator(expression.expression, environment);
2249
+ const coverage = environment.coverage;
1983
2250
  return (context) => {
1984
2251
  const elements: Value[] = [];
1985
- forEachBinding(expression.bounds, context, (scope) => {
2252
+ const add = (scope: Scope | undefined) => {
1986
2253
  addBoundedElement(elements, mapped(withScope(context, scope)));
1987
2254
  return false;
1988
- });
2255
+ };
2256
+ if (coverage) forEachChargedBinding(expression.bounds, context, coverage, add);
2257
+ else forEachBinding(expression.bounds, context, add);
1989
2258
  return createEnumeratedSet(elements);
1990
2259
  };
1991
2260
  }
@@ -1999,16 +2268,15 @@ const compileSetComprehension = (
1999
2268
  }
2000
2269
  const body = getEvaluator(expression.body, environment);
2001
2270
  const evaluateSet = getEvaluator(set, environment);
2271
+ const coverage = environment.coverage;
2002
2272
  return (context) => {
2003
- const elements = getChoiceElements(
2004
- evaluateSet(context),
2005
- expression,
2006
- set,
2007
- context.environment.runtime.version,
2008
- );
2273
+ const base = evaluateSet(context);
2274
+ const elements = getChoiceElements(base, expression, set, context.environment.runtime.version);
2275
+ const enumerator = coverage && createChargedEnumerator(coverage, base, elements, true);
2009
2276
  let chosen: Value | undefined;
2010
2277
  const pattern = expression.pattern;
2011
2278
  someElement(elements, (element) => {
2279
+ enumerator?.next();
2012
2280
  if (
2013
2281
  pattern.kind === "Tuple" &&
2014
2282
  getSequenceElements(element)?.length !== pattern.names.length
@@ -2022,8 +2290,9 @@ const compileSetComprehension = (
2022
2290
  chosen = getBoundValue(pattern, scope);
2023
2291
  return true;
2024
2292
  });
2025
- if (chosen === undefined) throw createNoChoiceError(expression);
2026
- return chosen;
2293
+ if (chosen !== undefined) return chosen;
2294
+ enumerator?.next();
2295
+ throw createNoChoiceError(expression);
2027
2296
  };
2028
2297
  };
2029
2298
 
@@ -2035,20 +2304,21 @@ export const hasDuplicateFields = (sortedFields: RecordField[]) =>
2035
2304
 
2036
2305
  const compileRecord = (recordFields: RecordField[], environment: Environment): Evaluator => {
2037
2306
  const fields = getSortedFields(recordFields);
2038
- const hasDuplicates = hasDuplicateFields(fields);
2039
- const values = fields.map((field) => getEvaluator(field.value, environment));
2040
- if (hasDuplicates) {
2307
+ const values = recordFields.map((field) => getEvaluator(field.value, environment));
2308
+ if (hasDuplicateFields(fields)) {
2041
2309
  return (context) =>
2042
2310
  createRecord(
2043
- fields.map((field, index): [string, Value] => [field.name, values[index](context)]),
2311
+ recordFields.map((field, index): [string, Value] => [field.name, values[index](context)]),
2044
2312
  );
2045
2313
  }
2046
2314
  const names = fields.map((field) => field.name);
2047
2315
  const writtenNames = recordFields.map((field) => field.name);
2048
2316
  if (writtenNames.some((name, index) => name !== names[index])) {
2317
+ const writtenIndexes = fields.map((field) => recordFields.indexOf(field));
2049
2318
  return (context) =>
2050
2319
  createWrittenRecord(
2051
2320
  names,
2321
+ writtenIndexes,
2052
2322
  values.map((value) => value(context)),
2053
2323
  writtenNames,
2054
2324
  );
@@ -2098,25 +2368,31 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2098
2368
  };
2099
2369
  case "And": {
2100
2370
  const operands = expression.operands.map(getChildEvaluator);
2101
- return (context) => {
2102
- for (let index = 0; index < operands.length; index++) {
2103
- const value = operands[index](context);
2104
- if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
2105
- if (!value) return false;
2106
- }
2107
- return true;
2108
- };
2371
+ return (
2372
+ compileTracedJunction(expression, operands, environment.callStack) ??
2373
+ ((context) => {
2374
+ for (let index = 0; index < operands.length; index++) {
2375
+ const value = operands[index](context);
2376
+ if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
2377
+ if (!value) return false;
2378
+ }
2379
+ return true;
2380
+ })
2381
+ );
2109
2382
  }
2110
2383
  case "Or": {
2111
2384
  const operands = expression.operands.map(getChildEvaluator);
2112
- return (context) => {
2113
- for (let index = 0; index < operands.length; index++) {
2114
- const value = operands[index](context);
2115
- if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
2116
- if (value) return true;
2117
- }
2118
- return false;
2119
- };
2385
+ return (
2386
+ compileTracedJunction(expression, operands, environment.callStack) ??
2387
+ ((context) => {
2388
+ for (let index = 0; index < operands.length; index++) {
2389
+ const value = operands[index](context);
2390
+ if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
2391
+ if (value) return true;
2392
+ }
2393
+ return false;
2394
+ })
2395
+ );
2120
2396
  }
2121
2397
  case "Prime": {
2122
2398
  const inner = getChildEvaluator(expression.expression);
@@ -2202,8 +2478,19 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2202
2478
  case "RecordSet": {
2203
2479
  const fields = getSortedFields(expression.fields);
2204
2480
  const names = fields.map((field) => field.name);
2205
- const sets = fields.map((field) => getChildEvaluator(field.value));
2206
- return (context) => ({ kind: "RecordSet", names, sets: sets.map((set) => set(context)) });
2481
+ const writtenIndexes = fields.map((field) => expression.fields.indexOf(field));
2482
+ const sets = expression.fields.map((field) => getChildEvaluator(field.value));
2483
+ if (writtenIndexes.every((writtenIndex, index) => writtenIndex === index)) {
2484
+ return (context) => ({ kind: "RecordSet", names, sets: sets.map((set) => set(context)) });
2485
+ }
2486
+ return (context) => {
2487
+ const writtenSets = sets.map((set) => set(context));
2488
+ return {
2489
+ kind: "RecordSet",
2490
+ names,
2491
+ sets: writtenIndexes.map((index) => writtenSets[index]),
2492
+ };
2493
+ };
2207
2494
  }
2208
2495
  case "Except":
2209
2496
  return compileExcept(expression, environment);
@@ -2270,6 +2557,8 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2270
2557
  }
2271
2558
  case "Label":
2272
2559
  return getChildEvaluator(expression.body);
2560
+ case "Selection":
2561
+ return getChildEvaluator(expression.expression);
2273
2562
  case "Subexpression":
2274
2563
  return () => {
2275
2564
  throw new TlaEvaluationError(