tla-ts 0.0.10-dev.37a75eb5b → 0.0.10-dev.45c0eaef5

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 (229) hide show
  1. package/dist/compile.cjs +3 -3
  2. package/dist/compile.js +1 -1
  3. package/dist/deciders.cjs +33 -33
  4. package/dist/deciders.js +53 -53
  5. package/dist/index.cjs +1 -1
  6. package/dist/index.d.cts +17 -3
  7. package/dist/index.d.ts +17 -3
  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 +55 -55
  14. package/dist/prove.js +78 -78
  15. package/dist/run.cjs +40 -42
  16. package/dist/run.js +42 -44
  17. package/dist/tlapm.cjs +1 -1
  18. package/dist/tlapm.js +2 -2
  19. package/dist/transfer.cjs +96 -91
  20. package/dist/transfer.js +95 -90
  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 +12 -10
  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 +418 -246
  30. package/src/cli/tlc-output.ts +17 -2
  31. package/src/cli/tlc.ts +5 -4
  32. package/src/cli/xml-exporter.ts +1 -1
  33. package/src/codegen.ts +23 -10
  34. package/src/coverage.ts +255 -18
  35. package/src/dependencies.ts +68 -15
  36. package/src/dfid.ts +93 -35
  37. package/src/environment.ts +106 -39
  38. package/src/errors.ts +7 -0
  39. package/src/evaluate.ts +415 -132
  40. package/src/exit-codes.ts +28 -15
  41. package/src/instances.ts +135 -11
  42. package/src/java-hash.ts +14 -0
  43. package/src/java-overrides.ts +2 -2
  44. package/src/levels.ts +674 -236
  45. package/src/lexer.ts +12 -2
  46. package/src/liveness-checker.ts +161 -60
  47. package/src/liveness.ts +55 -10
  48. package/src/obligations/index.ts +1 -1
  49. package/src/obligations/normalize.ts +1 -4
  50. package/src/obligations/printer.ts +5 -5
  51. package/src/obligations/source.ts +2 -0
  52. package/src/parser.ts +110 -111
  53. package/src/prover/isabelle/isar/attrib.ts +4 -4
  54. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  55. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  56. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  57. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  58. package/src/prover/isabelle/pure/term.ts +3 -3
  59. package/src/prover/prep/md5.ts +26 -29
  60. package/src/prover/smt/rewrite.ts +2 -7
  61. package/src/prover/smt/simplify.ts +1 -1
  62. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  63. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  64. package/src/prover/smt/solver/asserted-formulas.ts +164 -58
  65. package/src/prover/smt/solver/ast-lt.ts +1 -1
  66. package/src/prover/smt/solver/ast.ts +65 -13
  67. package/src/prover/smt/solver/auf-solver.ts +23 -12
  68. package/src/prover/smt/solver/bit-blast-tactic.ts +27 -1
  69. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  70. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  71. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  72. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  73. package/src/prover/smt/solver/card2bv.ts +35 -18
  74. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  75. package/src/prover/smt/solver/context.ts +65 -14
  76. package/src/prover/smt/solver/ctx-simplify.ts +1 -2
  77. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  78. package/src/prover/smt/solver/dependent-expr-state.ts +28 -16
  79. package/src/prover/smt/solver/diff-neq.ts +1 -2
  80. package/src/prover/smt/solver/dt2bv-tactic.ts +57 -21
  81. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  82. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  83. package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
  84. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  85. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  86. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  87. package/src/prover/smt/solver/euf/egraph.ts +3 -9
  88. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  89. package/src/prover/smt/solver/euf/mam.ts +1 -5
  90. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  91. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  92. package/src/prover/smt/solver/fd-solver.ts +608 -141
  93. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  94. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  95. package/src/prover/smt/solver/goal.ts +4 -3
  96. package/src/prover/smt/solver/hashtable.ts +4 -0
  97. package/src/prover/smt/solver/internalizer.ts +1 -1
  98. package/src/prover/smt/solver/logic-tactics.ts +15 -5
  99. package/src/prover/smt/solver/lp/core-solver.ts +12 -8
  100. package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
  101. package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
  102. package/src/prover/smt/solver/lp/nla-grobner.ts +2 -2
  103. package/src/prover/smt/solver/lp/pdd.ts +2 -3
  104. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  105. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  106. package/src/prover/smt/solver/maxcore.ts +2 -1
  107. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  108. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  109. package/src/prover/smt/solver/model-checker.ts +1 -1
  110. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  111. package/src/prover/smt/solver/model-generator.ts +85 -43
  112. package/src/prover/smt/solver/mpf.ts +2 -4
  113. package/src/prover/smt/solver/mus.ts +2 -3
  114. package/src/prover/smt/solver/muz/dl-context.ts +14 -42
  115. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  116. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  117. package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
  118. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  119. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  120. package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
  121. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  122. package/src/prover/smt/solver/muz/spacer-context.ts +1 -4
  123. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  124. package/src/prover/smt/solver/nlqsat.ts +1 -1
  125. package/src/prover/smt/solver/nlsat/algebraic.ts +4 -5
  126. package/src/prover/smt/solver/nlsat/levelwise.ts +0 -4
  127. package/src/prover/smt/solver/nlsat/polynomial.ts +1 -36
  128. package/src/prover/smt/solver/nlsat/upolynomial.ts +1 -1
  129. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  130. package/src/prover/smt/solver/nnf.ts +6 -2
  131. package/src/prover/smt/solver/opt-context.ts +16 -7
  132. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  133. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  134. package/src/prover/smt/solver/opt-solver.ts +4 -3
  135. package/src/prover/smt/solver/optsmt.ts +1 -1
  136. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  137. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  138. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  139. package/src/prover/smt/solver/probes.ts +88 -23
  140. package/src/prover/smt/solver/proto-model.ts +8 -8
  141. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  142. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  143. package/src/prover/smt/solver/qe-lite.ts +2 -2
  144. package/src/prover/smt/solver/qe.ts +3 -2
  145. package/src/prover/smt/solver/qsat.ts +23 -8
  146. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  147. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  148. package/src/prover/smt/solver/rewriter.ts +31 -25
  149. package/src/prover/smt/solver/rlimit.ts +7 -3
  150. package/src/prover/smt/solver/sat/config.ts +1 -1
  151. package/src/prover/smt/solver/sat/goal2sat.ts +65 -12
  152. package/src/prover/smt/solver/sat/inc-sat-solver.ts +129 -43
  153. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  154. package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
  155. package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
  156. package/src/prover/smt/solver/sat/sat-tactic.ts +15 -6
  157. package/src/prover/smt/solver/sat/sat2goal.ts +72 -48
  158. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  159. package/src/prover/smt/solver/sat/solver.ts +27 -47
  160. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  161. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  162. package/src/prover/smt/solver/seq-derive.ts +1 -1
  163. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  164. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  165. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  166. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  167. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  168. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  169. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  170. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  171. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  172. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  173. package/src/prover/smt/solver/smt-kernel.ts +40 -6
  174. package/src/prover/smt/solver/smt-setup.ts +106 -13
  175. package/src/prover/smt/solver/smtlib-parser.ts +579 -214
  176. package/src/prover/smt/solver/smtlib-script.ts +600 -170
  177. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  178. package/src/prover/smt/solver/solver.ts +18 -3
  179. package/src/prover/smt/solver/tactic.ts +342 -196
  180. package/src/prover/smt/solver/theory-bv.ts +13 -3
  181. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  182. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  183. package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
  184. package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
  185. package/src/prover/smt/solver/theory-lra-state.ts +1 -1
  186. package/src/prover/smt/solver/theory-lra.ts +1 -1
  187. package/src/prover/smt/solver/theory-pb.ts +24 -7
  188. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  189. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  190. package/src/prover/smt/solver/theory-without-terms.ts +24 -0
  191. package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
  192. package/src/prover/tlapm/cache.ts +8 -8
  193. package/src/prover/zenon/index-table.ts +5 -2
  194. package/src/prover/zenon/isar-case.ts +1 -1
  195. package/src/prover/zenon/isar.ts +2 -2
  196. package/src/prover/zenon/phrase.ts +1 -1
  197. package/src/resolve.ts +1226 -246
  198. package/src/runtime.ts +19 -2
  199. package/src/sany/builtins.ts +10 -10
  200. package/src/sany/generation.ts +4 -2
  201. package/src/sany/generator-def-entries.ts +123 -36
  202. package/src/sany/generator-definitions.ts +4 -2
  203. package/src/sany/generator-expressions.ts +51 -20
  204. package/src/sany/generator-proofs.ts +17 -11
  205. package/src/sany/generator.ts +11 -5
  206. package/src/sany/lexer.ts +15 -7
  207. package/src/sany/modules.ts +4 -2
  208. package/src/sany/nodes.ts +1 -1
  209. package/src/sany/selectors.ts +11 -6
  210. package/src/sany/xml.ts +2 -3
  211. package/src/search.ts +283 -126
  212. package/src/simulate.ts +247 -185
  213. package/src/spec-description.ts +15 -7
  214. package/src/standard-definitions.ts +1 -0
  215. package/src/standard-modules.ts +56 -22
  216. package/src/subexpressions.ts +563 -139
  217. package/src/successors.ts +50 -20
  218. package/src/symmetry.ts +2 -1
  219. package/src/tlc/jar-data.ts +1 -3
  220. package/src/tlc/messages.ts +3 -3
  221. package/src/tlc/random.ts +2 -1
  222. package/src/tlc/replay.ts +147 -46
  223. package/src/tlc/tlc-operators.ts +10 -8
  224. package/src/tlc/tlcext-operators.ts +26 -10
  225. package/src/tlc/trace-spec.ts +9 -22
  226. package/src/trace-liveness.ts +529 -0
  227. package/src/typed-tier.ts +52 -31
  228. package/src/typescript/types.ts +2 -2
  229. 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 };
@@ -673,7 +716,7 @@ const getLazyFunctionTemplate = (bounds: Bound[], body: Expression) => {
673
716
  },
674
717
  ],
675
718
  ),
676
- body: formatRange(range),
719
+ body: describeNode(body),
677
720
  };
678
721
  };
679
722
 
@@ -719,28 +762,29 @@ const getBoundTupleLengths = (bounds: Bound[]) =>
719
762
  bound.pattern.kind === "Tuple" ? bound.pattern.names.length : undefined,
720
763
  );
721
764
 
722
- const getDefinitionSource = (definition: FunctionDefinition): Expression => ({
723
- kind: "FunctionConstruction",
724
- bounds: definition.bounds,
725
- body: definition.body,
726
- location: definition.location,
727
- });
728
-
729
765
  const createRecursiveFunction = (
730
766
  definition: FunctionDefinition,
731
767
  context: Context,
732
768
  ): RebindableLazyFunction => {
733
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;
734
780
  const functionValue = createLazyFunction(
735
781
  domain,
736
- (argument, self) =>
737
- evaluate(
738
- definition.body,
739
- withScope(
740
- context,
741
- bindArgument(definition.bounds, bindValue(undefined, definition.name, self), argument),
742
- ),
743
- ),
782
+ coverage
783
+ ? (argument, self) =>
784
+ coverage.current === -1
785
+ ? compute(argument, self)
786
+ : runAtCoverageNode(coverage, node, () => compute(argument, self))
787
+ : compute,
744
788
  getLazyFunctionSource(
745
789
  getLazyFunctionTemplate(definition.bounds, definition.body),
746
790
  definition.bounds,
@@ -792,9 +836,17 @@ const compileDefinitionBody = (definition: Definition, environment: Environment)
792
836
  };
793
837
  }
794
838
  if (definition.kind !== "Function") return getEntryEvaluator(definition.body, environment);
795
- if (definition.isSelfReferential)
796
- return (context) => createRecursiveFunction(definition, context);
797
- 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,
798
850
  };
799
851
 
800
852
  const getDefinitionEvaluator = (definition: Definition, environment: Environment): Evaluator => {
@@ -803,8 +855,15 @@ const getDefinitionEvaluator = (definition: Definition, environment: Environment
803
855
  const body = compileDefinitionBody(definition, environment);
804
856
  const definitionId = environment.facts.ids.get(definition);
805
857
  const startupValues = environment.startupValues;
806
- const evaluator: Evaluator =
807
- 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
808
867
  ? (context) => body(withScope(context, undefined))
809
868
  : (context) => startupValues[definitionId] ?? body(withScope(context, undefined));
810
869
  environment.definitionEvaluators.set(definition, evaluator);
@@ -821,7 +880,7 @@ export const evaluateStartupDefinitions = (definitions: Definition[], environmen
821
880
  if (definition.kind === "Operator" && definition.params.length > 0) return;
822
881
  const name = definition.name;
823
882
  if (environment.constants.has(name) || environment.substitutions.has(name)) return;
824
- if (!isConstantLevel(definition, environment)) return;
883
+ if (!isEvaluatedAtStartup(definition, environment)) return;
825
884
  const definitionId = environment.facts.ids.get(definition);
826
885
  if (definitionId === undefined || environment.startupValues[definitionId] !== undefined) return;
827
886
  const context = { environment, scope: undefined, state: undefined, next: undefined };
@@ -973,6 +1032,7 @@ const isOperatorArgument = (expression: Expression, context: Context) => {
973
1032
  return operator !== undefined && getArity(operator) > 0;
974
1033
  };
975
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.
976
1036
  const evaluateBuiltinArguments = (args: Expression[], context: Context) =>
977
1037
  args.map((arg) =>
978
1038
  isOperatorArgument(arg, context)
@@ -1087,20 +1147,29 @@ interface ReevaluatedDefinitions {
1087
1147
  streamed: ReadonlySet<Definition>;
1088
1148
  }
1089
1149
 
1090
- const letFunctionConstructions = new WeakMap<FunctionDefinition, Expression>();
1150
+ const isRecursiveOperator = (definition: Definition) =>
1151
+ definition.kind === "Operator" && definition.isRecursive && definition.params.length > 0;
1091
1152
 
1092
- const getLetFunctionConstruction = (definition: FunctionDefinition): Expression => {
1093
- const known = letFunctionConstructions.get(definition);
1094
- if (known) return known;
1095
- const construction: Expression = {
1096
- kind: "FunctionConstruction",
1097
- bounds: definition.bounds,
1098
- body: definition.body,
1099
- location: definition.location,
1100
- isRecursive: true,
1101
- };
1102
- letFunctionConstructions.set(definition, construction);
1103
- 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;
1104
1173
  };
1105
1174
 
1106
1175
  export const bindDefinitions = (
@@ -1113,16 +1182,29 @@ export const bindDefinitions = (
1113
1182
  binding: { kind: "Value", value: false },
1114
1183
  parent: undefined,
1115
1184
  }));
1116
- const scope = nodes.reduce<Scope | undefined>((parent, node) => {
1117
- node.parent = parent;
1118
- return node;
1119
- }, context.scope);
1120
- 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;
1121
1203
  nodes[index].binding =
1122
1204
  definition.kind === "Function"
1123
1205
  ? {
1124
1206
  kind: "Thunk",
1125
- expression: getLetFunctionConstruction(definition),
1207
+ expression: getFunctionConstruction(definition, true),
1126
1208
  scope,
1127
1209
  state: context.state,
1128
1210
  next: context.next,
@@ -1137,19 +1219,19 @@ export const bindDefinitions = (
1137
1219
  name: definition.name,
1138
1220
  params: definition.params,
1139
1221
  body: definition.body,
1140
- scope,
1222
+ scope: ownScope,
1141
1223
  },
1142
1224
  }
1143
1225
  : {
1144
1226
  kind: "Thunk",
1145
1227
  expression: definition.body,
1146
- scope,
1228
+ scope: ownScope,
1147
1229
  state: context.state,
1148
1230
  next: context.next,
1149
1231
  cache: undefined,
1150
1232
  isStreamed: reevaluated?.streamed.has(definition) ?? false,
1151
1233
  };
1152
- });
1234
+ }
1153
1235
  const coverage = context.environment.coverage;
1154
1236
  if (coverage && coverage.current !== -1) {
1155
1237
  nodes.forEach((node) => {
@@ -1179,7 +1261,9 @@ const evaluateLocalIdentifier = (name: string, expression: Expression, context:
1179
1261
  if (global?.kind === "Definition") {
1180
1262
  return getDefinitionEvaluator(global.definition, context.environment)(context);
1181
1263
  }
1182
- const builtin = context.environment.builtins.get(name);
1264
+ const builtin = context.environment.builtins.get(
1265
+ context.environment.substitutions.get(name) ?? name,
1266
+ );
1183
1267
  if (builtin?.arity === 0) return builtin.evaluate([], context);
1184
1268
  throw new TlaEvaluationError(
1185
1269
  `In evaluation, the identifier ${name} is either undefined or not an operator.\n${describeRange(expression)}`,
@@ -1190,7 +1274,9 @@ export const getReevaluatedDefinitions = (
1190
1274
  definitions: Definition[],
1191
1275
  environment: Environment,
1192
1276
  ): ReevaluatedDefinitions => ({
1193
- impure: new Set(definitions.filter((definition) => isImpureDefinition(definition, environment))),
1277
+ impure: new Set(
1278
+ definitions.filter((definition) => isImpureDefinition(definition, environment, "varying")),
1279
+ ),
1194
1280
  streamed: new Set(
1195
1281
  definitions.filter((definition) => isImpureDefinition(definition, environment, "streamed")),
1196
1282
  ),
@@ -1322,7 +1408,6 @@ const headFingerprint = (callStack: CallStack, source: Expression, error: unknow
1322
1408
 
1323
1409
  export const createTracingEnvironment = (environment: Environment): Environment => ({
1324
1410
  ...environment,
1325
- coverage: undefined,
1326
1411
  evaluators: new WeakMap(),
1327
1412
  entryEvaluators: new WeakMap(),
1328
1413
  definitionEvaluators: new WeakMap(),
@@ -1335,6 +1420,41 @@ export const createTracingEnvironment = (environment: Environment): Environment
1335
1420
  },
1336
1421
  });
1337
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
+
1338
1458
  const traceFrames =
1339
1459
  (
1340
1460
  expression: Expression,
@@ -1362,9 +1482,21 @@ const countEvaluator =
1362
1482
  coverage.current = node;
1363
1483
  try {
1364
1484
  const value = evaluator(context);
1365
- if (typeof value === "object" && expression.kind === "SetEnumeration") {
1366
- coverage.values.set(value, node);
1367
- }
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);
1368
1500
  return value;
1369
1501
  } finally {
1370
1502
  coverage.current = outer;
@@ -1514,6 +1646,26 @@ const compileClosureCall = (
1514
1646
  };
1515
1647
  };
1516
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
+
1517
1669
  const compileApply = (
1518
1670
  expression: Expression & { kind: "Apply" },
1519
1671
  environment: Environment,
@@ -1553,19 +1705,63 @@ const compileApply = (
1553
1705
  return (context) => domain(operand(context));
1554
1706
  }
1555
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.
1556
1709
  const isCached =
1557
1710
  !contextualApplications.has(expression) && !isNonconstant(args[0], environment);
1558
- return (context) =>
1559
- global.evaluate(
1560
- getLazyArguments(args, context),
1561
- isCached && context.scope === undefined ? undefined : context,
1562
- );
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
+ };
1563
1748
  }
1564
- 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) {
1565
1752
  const left = getEvaluator(args[0], environment);
1566
1753
  const right = getEvaluator(args[1], environment);
1567
- const subset = getSubsetOperator(expression, global);
1568
- 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
+ };
1569
1765
  }
1570
1766
  if (global?.kind === "Builtin") return compileBuiltinCall(global, args, environment);
1571
1767
  if (expression.operator === "\\cdot" && args.length === 2) {
@@ -1598,6 +1794,18 @@ const compileQuantifier = (
1598
1794
  const isForall = expression.kind === "Forall";
1599
1795
  const body = getEvaluator(expression.body, environment);
1600
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
+ }
1601
1809
  if (expression.bounds.length === 1 && bound.pattern.kind === "Name") {
1602
1810
  const name = bound.pattern.name;
1603
1811
  const set = getEvaluator(bound.set, environment);
@@ -1723,8 +1931,14 @@ export const getFunctionBuilder = (
1723
1931
  return markLambdaFunction(functionValue);
1724
1932
  }
1725
1933
  const pairs: [Value, Value][] = [];
1726
- const sets = mapBoundSets(bounds, (set) =>
1727
- 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
+ ),
1728
1942
  );
1729
1943
  forEachBoundElement(bounds, sets, context.scope, (scope) => {
1730
1944
  const key =
@@ -1739,13 +1953,22 @@ export const getFunctionBuilder = (
1739
1953
  const template = getLazyFunctionTemplate(bounds, expression.body);
1740
1954
  const boundTupleLengths = getBoundTupleLengths(bounds);
1741
1955
  const bodyNames = getScopeNames(expression.body);
1956
+ const coverage = environment.coverage;
1742
1957
  const createLazy = (domain: Value, context: Context) => {
1743
1958
  const scope = trimScope(context.scope, bodyNames);
1744
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;
1745
1963
  const functionValue = keepLambda({
1746
1964
  value: createLazyFunction(
1747
1965
  domain,
1748
- (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,
1749
1972
  getLazyFunctionSource(template, bounds, domain),
1750
1973
  boundTupleLengths,
1751
1974
  ),
@@ -1797,6 +2020,23 @@ const compileFunctionConstruction = (
1797
2020
  ): Evaluator => {
1798
2021
  const build = getFunctionBuilder(expression, environment).build;
1799
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
+ }
1800
2040
  if (bounds.length === 1 && bounds[0].pattern.kind === "Name") {
1801
2041
  const set = getEvaluator(bounds[0].set, environment);
1802
2042
  return (context) => build(set(context), context);
@@ -1870,29 +2110,19 @@ export const getLazyFilter = (
1870
2110
  ) => {
1871
2111
  const predicate = getEvaluator(expression.predicate, environment);
1872
2112
  const pattern = expression.bound.pattern;
1873
- const range = expression.predicate.location.range;
1874
- const source = range && {
2113
+ const predicateNode = describeNode(expression.predicate);
2114
+ const source = expression.predicate.location.range && {
1875
2115
  names: pattern.kind === "Name" ? pattern.name : pattern.names.join(", "),
1876
- predicate: formatRange(range),
2116
+ predicate: predicateNode,
1877
2117
  };
1878
- const predicateNode = describeNode(expression.predicate);
1879
2118
  const coverage = environment.coverage;
1880
- const testCovered = (node: number, isMember: boolean, test: () => Value) => {
1881
- if (!coverage || node === -1) return test();
1882
- if (!isMember) coverage.secondary[node]++;
1883
- const value = runAtCoverageNode(coverage, isMember ? -1 : node, test);
1884
- if (!isMember && value === true) coverage.secondary[node]++;
1885
- return value;
1886
- };
1887
2119
  const createFiltered = (
1888
2120
  base: Value,
1889
2121
  context: Context,
1890
2122
  evaluator: Evaluator,
1891
2123
  node: number,
1892
- ): RebindableFilteredSet => ({
1893
- kind: "FilteredSet",
1894
- base,
1895
- test: (element, isMember) => {
2124
+ ): RebindableFilteredSet => {
2125
+ const test = (element: Value, isMember: boolean) => {
1896
2126
  if (
1897
2127
  pattern.kind === "Tuple" &&
1898
2128
  getSequenceElements(element)?.length !== pattern.names.length
@@ -1901,29 +2131,60 @@ export const getLazyFilter = (
1901
2131
  `Attempted to check if the value:\n${prettyPrint(formatValue(element))}\nis an element of a set of ${pattern.names.length}-tuples.`,
1902
2132
  );
1903
2133
  }
1904
- const value = testCovered(node, isMember, () =>
1905
- evaluator(withScope(context, bindPattern(context.scope, pattern, element))),
1906
- );
2134
+ const value = evaluator(withScope(context, bindPattern(context.scope, pattern, element)));
1907
2135
  if (typeof value !== "boolean") {
1908
2136
  throw new TlaEvaluationError(
1909
2137
  `${isMember ? "The evaluation of predicate" : "Evaluating predicate"} ${predicateNode} yielded non-Boolean value.`,
1910
2138
  );
1911
2139
  }
1912
2140
  return value;
1913
- },
1914
- source,
1915
- rebind: (tracing) =>
2141
+ };
2142
+ const rebind = (tracing: Environment) =>
1916
2143
  createFiltered(
1917
2144
  base,
1918
2145
  { ...context, environment: tracing },
1919
2146
  getEvaluator(expression.predicate, tracing),
1920
2147
  -1,
1921
- ),
1922
- });
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
+ };
1923
2170
  return (base: Value, context: Context, node = -1) =>
1924
2171
  createFiltered(base, context, predicate, node);
1925
2172
  };
1926
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
+
1927
2188
  export const expectFilterPredicate = (
1928
2189
  value: Value,
1929
2190
  expression: Expression & { kind: "SetFilter" },
@@ -1966,32 +2227,34 @@ const compileSetComprehension = (
1966
2227
  const filterLazily = getLazyFilter(expression, environment);
1967
2228
  const pattern = expression.bound.pattern;
1968
2229
  const coverage = environment.coverage;
2230
+ const isUniform = isUniformPredicate(expression, environment);
1969
2231
  return (context) => {
1970
2232
  const base = set(context);
1971
2233
  if (!isReducibleSet(base)) return filterLazily(base, context, coverage?.current);
1972
2234
  const kept: Value[] = [];
1973
- 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;
1974
2239
  const value = predicate(withScope(context, bindPattern(context.scope, pattern, element)));
1975
2240
  if (expectFilterPredicate(value, expression)) addBoundedElement(kept, element);
1976
- };
1977
- const elements = base.kind === "Interval" ? base : toFiniteSet(base).elements;
1978
- forEachElement(elements, visit);
1979
- if (coverage && coverage.current !== -1) {
1980
- coverage.secondary[coverage.current] +=
1981
- (Array.isArray(elements) ? elements.length : elements.high - elements.low + 1) +
1982
- kept.length;
2241
+ else if (isUniform) break;
1983
2242
  }
2243
+ if (coverage) costCoverage(coverage, base, size + 1);
1984
2244
  return createNormalizedSet(kept);
1985
2245
  };
1986
2246
  }
1987
2247
  if (expression.kind === "SetMap") {
1988
2248
  const mapped = getEvaluator(expression.expression, environment);
2249
+ const coverage = environment.coverage;
1989
2250
  return (context) => {
1990
2251
  const elements: Value[] = [];
1991
- forEachBinding(expression.bounds, context, (scope) => {
2252
+ const add = (scope: Scope | undefined) => {
1992
2253
  addBoundedElement(elements, mapped(withScope(context, scope)));
1993
2254
  return false;
1994
- });
2255
+ };
2256
+ if (coverage) forEachChargedBinding(expression.bounds, context, coverage, add);
2257
+ else forEachBinding(expression.bounds, context, add);
1995
2258
  return createEnumeratedSet(elements);
1996
2259
  };
1997
2260
  }
@@ -2005,16 +2268,15 @@ const compileSetComprehension = (
2005
2268
  }
2006
2269
  const body = getEvaluator(expression.body, environment);
2007
2270
  const evaluateSet = getEvaluator(set, environment);
2271
+ const coverage = environment.coverage;
2008
2272
  return (context) => {
2009
- const elements = getChoiceElements(
2010
- evaluateSet(context),
2011
- expression,
2012
- set,
2013
- context.environment.runtime.version,
2014
- );
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);
2015
2276
  let chosen: Value | undefined;
2016
2277
  const pattern = expression.pattern;
2017
2278
  someElement(elements, (element) => {
2279
+ enumerator?.next();
2018
2280
  if (
2019
2281
  pattern.kind === "Tuple" &&
2020
2282
  getSequenceElements(element)?.length !== pattern.names.length
@@ -2028,8 +2290,9 @@ const compileSetComprehension = (
2028
2290
  chosen = getBoundValue(pattern, scope);
2029
2291
  return true;
2030
2292
  });
2031
- if (chosen === undefined) throw createNoChoiceError(expression);
2032
- return chosen;
2293
+ if (chosen !== undefined) return chosen;
2294
+ enumerator?.next();
2295
+ throw createNoChoiceError(expression);
2033
2296
  };
2034
2297
  };
2035
2298
 
@@ -2041,20 +2304,21 @@ export const hasDuplicateFields = (sortedFields: RecordField[]) =>
2041
2304
 
2042
2305
  const compileRecord = (recordFields: RecordField[], environment: Environment): Evaluator => {
2043
2306
  const fields = getSortedFields(recordFields);
2044
- const hasDuplicates = hasDuplicateFields(fields);
2045
- const values = fields.map((field) => getEvaluator(field.value, environment));
2046
- if (hasDuplicates) {
2307
+ const values = recordFields.map((field) => getEvaluator(field.value, environment));
2308
+ if (hasDuplicateFields(fields)) {
2047
2309
  return (context) =>
2048
2310
  createRecord(
2049
- fields.map((field, index): [string, Value] => [field.name, values[index](context)]),
2311
+ recordFields.map((field, index): [string, Value] => [field.name, values[index](context)]),
2050
2312
  );
2051
2313
  }
2052
2314
  const names = fields.map((field) => field.name);
2053
2315
  const writtenNames = recordFields.map((field) => field.name);
2054
2316
  if (writtenNames.some((name, index) => name !== names[index])) {
2317
+ const writtenIndexes = fields.map((field) => recordFields.indexOf(field));
2055
2318
  return (context) =>
2056
2319
  createWrittenRecord(
2057
2320
  names,
2321
+ writtenIndexes,
2058
2322
  values.map((value) => value(context)),
2059
2323
  writtenNames,
2060
2324
  );
@@ -2104,25 +2368,31 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2104
2368
  };
2105
2369
  case "And": {
2106
2370
  const operands = expression.operands.map(getChildEvaluator);
2107
- return (context) => {
2108
- for (let index = 0; index < operands.length; index++) {
2109
- const value = operands[index](context);
2110
- if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
2111
- if (!value) return false;
2112
- }
2113
- return true;
2114
- };
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
+ );
2115
2382
  }
2116
2383
  case "Or": {
2117
2384
  const operands = expression.operands.map(getChildEvaluator);
2118
- return (context) => {
2119
- for (let index = 0; index < operands.length; index++) {
2120
- const value = operands[index](context);
2121
- if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
2122
- if (value) return true;
2123
- }
2124
- return false;
2125
- };
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
+ );
2126
2396
  }
2127
2397
  case "Prime": {
2128
2398
  const inner = getChildEvaluator(expression.expression);
@@ -2208,8 +2478,19 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2208
2478
  case "RecordSet": {
2209
2479
  const fields = getSortedFields(expression.fields);
2210
2480
  const names = fields.map((field) => field.name);
2211
- const sets = fields.map((field) => getChildEvaluator(field.value));
2212
- 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
+ };
2213
2494
  }
2214
2495
  case "Except":
2215
2496
  return compileExcept(expression, environment);
@@ -2276,6 +2557,8 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2276
2557
  }
2277
2558
  case "Label":
2278
2559
  return getChildEvaluator(expression.body);
2560
+ case "Selection":
2561
+ return getChildEvaluator(expression.expression);
2279
2562
  case "Subexpression":
2280
2563
  return () => {
2281
2564
  throw new TlaEvaluationError(