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

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 (252) 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 +49 -44
  20. package/dist/transfer.js +48 -43
  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 +14 -2
  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 +116 -64
  29. package/src/check.ts +516 -280
  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 +190 -1
  37. package/src/dependencies.ts +68 -15
  38. package/src/dfid.ts +101 -36
  39. package/src/environment.ts +123 -38
  40. package/src/errors.ts +7 -0
  41. package/src/evaluate.ts +370 -99
  42. package/src/exit-codes.ts +28 -14
  43. package/src/instances.ts +135 -11
  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 +51 -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/arith-rewriter.ts +11 -3
  67. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  68. package/src/prover/smt/solver/asserted-formulas.ts +171 -58
  69. package/src/prover/smt/solver/ast-lt.ts +1 -1
  70. package/src/prover/smt/solver/ast.ts +66 -14
  71. package/src/prover/smt/solver/auf-solver.ts +23 -12
  72. package/src/prover/smt/solver/bit-blast-tactic.ts +27 -1
  73. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  74. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  75. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  76. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  77. package/src/prover/smt/solver/card2bv.ts +35 -18
  78. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  79. package/src/prover/smt/solver/context.ts +84 -15
  80. package/src/prover/smt/solver/ctx-simplify.ts +1 -2
  81. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  82. package/src/prover/smt/solver/dependent-expr-state.ts +28 -16
  83. package/src/prover/smt/solver/diff-neq.ts +1 -2
  84. package/src/prover/smt/solver/dt2bv-tactic.ts +57 -21
  85. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  86. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  87. package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
  88. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  89. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  90. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  91. package/src/prover/smt/solver/euf/egraph.ts +4 -11
  92. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  93. package/src/prover/smt/solver/euf/mam.ts +1 -5
  94. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  95. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  96. package/src/prover/smt/solver/expr2polynomial.ts +204 -79
  97. package/src/prover/smt/solver/factor.ts +36 -14
  98. package/src/prover/smt/solver/fd-solver.ts +608 -139
  99. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  100. package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
  101. package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
  102. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  103. package/src/prover/smt/solver/goal.ts +6 -3
  104. package/src/prover/smt/solver/goal2nlsat.ts +57 -30
  105. package/src/prover/smt/solver/hashtable.ts +4 -0
  106. package/src/prover/smt/solver/internalizer.ts +1 -1
  107. package/src/prover/smt/solver/logic-tactics.ts +15 -5
  108. package/src/prover/smt/solver/lp/core-solver.ts +12 -8
  109. package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
  110. package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
  111. package/src/prover/smt/solver/lp/nla-core.ts +1 -1
  112. package/src/prover/smt/solver/lp/nla-grobner.ts +158 -80
  113. package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
  114. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
  115. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
  116. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
  117. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  118. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  119. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  120. package/src/prover/smt/solver/maxcore.ts +2 -1
  121. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  122. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  123. package/src/prover/smt/solver/model-checker.ts +1 -1
  124. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  125. package/src/prover/smt/solver/model-generator.ts +85 -43
  126. package/src/prover/smt/solver/mpf.ts +2 -4
  127. package/src/prover/smt/solver/mus.ts +2 -3
  128. package/src/prover/smt/solver/muz/dl-context.ts +22 -44
  129. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  130. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  131. package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
  132. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  133. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  134. package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
  135. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  136. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  137. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  138. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  139. package/src/prover/smt/solver/nlqsat.ts +1 -1
  140. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  141. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  142. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  143. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  144. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  145. package/src/prover/smt/solver/nlsat/solver.ts +74 -64
  146. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  147. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  148. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  149. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  150. package/src/prover/smt/solver/nnf.ts +6 -2
  151. package/src/prover/smt/solver/opt-context.ts +21 -7
  152. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  153. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  154. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  155. package/src/prover/smt/solver/opt-solver.ts +10 -6
  156. package/src/prover/smt/solver/optsmt.ts +1 -1
  157. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  158. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  159. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  160. package/src/prover/smt/solver/probes.ts +88 -23
  161. package/src/prover/smt/solver/proto-model.ts +8 -8
  162. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  163. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  164. package/src/prover/smt/solver/qe-lite.ts +2 -2
  165. package/src/prover/smt/solver/qe.ts +3 -2
  166. package/src/prover/smt/solver/qsat.ts +23 -8
  167. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  168. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  169. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  170. package/src/prover/smt/solver/rewriter.ts +31 -25
  171. package/src/prover/smt/solver/rlimit.ts +7 -3
  172. package/src/prover/smt/solver/sat/config.ts +1 -1
  173. package/src/prover/smt/solver/sat/goal2sat.ts +65 -12
  174. package/src/prover/smt/solver/sat/inc-sat-solver.ts +129 -43
  175. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  176. package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
  177. package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
  178. package/src/prover/smt/solver/sat/sat-tactic.ts +17 -7
  179. package/src/prover/smt/solver/sat/sat2goal.ts +72 -48
  180. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  181. package/src/prover/smt/solver/sat/solver.ts +27 -47
  182. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  183. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  184. package/src/prover/smt/solver/seq-derive.ts +2 -2
  185. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  186. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  187. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  188. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  189. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  190. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  191. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  192. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  193. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  194. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  195. package/src/prover/smt/solver/smt-kernel.ts +48 -7
  196. package/src/prover/smt/solver/smt-setup.ts +106 -13
  197. package/src/prover/smt/solver/smtlib-parser.ts +589 -224
  198. package/src/prover/smt/solver/smtlib-script.ts +713 -210
  199. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  200. package/src/prover/smt/solver/solver.ts +18 -3
  201. package/src/prover/smt/solver/tactic.ts +350 -195
  202. package/src/prover/smt/solver/theory-bv.ts +13 -3
  203. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  204. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  205. package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
  206. package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
  207. package/src/prover/smt/solver/theory-lra-state.ts +1 -1
  208. package/src/prover/smt/solver/theory-lra.ts +1 -1
  209. package/src/prover/smt/solver/theory-pb.ts +24 -7
  210. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  211. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  212. package/src/prover/smt/solver/theory-without-terms.ts +24 -0
  213. package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
  214. package/src/prover/tlapm/cache.ts +8 -8
  215. package/src/prover/zenon/index-table.ts +5 -2
  216. package/src/prover/zenon/isar-case.ts +1 -1
  217. package/src/prover/zenon/isar.ts +2 -2
  218. package/src/prover/zenon/phrase.ts +1 -1
  219. package/src/resolve.ts +1274 -257
  220. package/src/runtime.ts +7 -1
  221. package/src/sany/builtins.ts +10 -10
  222. package/src/sany/generation.ts +5 -15
  223. package/src/sany/generator-def-entries.ts +123 -36
  224. package/src/sany/generator-definitions.ts +5 -3
  225. package/src/sany/generator-expressions.ts +60 -37
  226. package/src/sany/generator-proofs.ts +18 -12
  227. package/src/sany/generator.ts +12 -6
  228. package/src/sany/lexer.ts +15 -7
  229. package/src/sany/modules.ts +4 -2
  230. package/src/sany/nodes.ts +1 -1
  231. package/src/sany/selectors.ts +11 -6
  232. package/src/sany/xml.ts +2 -3
  233. package/src/search.ts +319 -135
  234. package/src/simulate.ts +235 -182
  235. package/src/spec-description.ts +8 -6
  236. package/src/standard-definitions.ts +1 -0
  237. package/src/standard-modules.ts +56 -22
  238. package/src/subexpressions.ts +564 -138
  239. package/src/successors.ts +37 -13
  240. package/src/symmetry.ts +2 -1
  241. package/src/tlc/jar-data.ts +10 -0
  242. package/src/tlc/messages.ts +3 -3
  243. package/src/tlc/order.ts +14 -3
  244. package/src/tlc/random.ts +2 -1
  245. package/src/tlc/replay.ts +67 -43
  246. package/src/tlc/tlc-operators.ts +10 -8
  247. package/src/tlc/tlcext-operators.ts +44 -15
  248. package/src/tlc/trace-spec.ts +9 -22
  249. package/src/trace-liveness.ts +529 -0
  250. package/src/typed-tier.ts +52 -31
  251. package/src/typescript/types.ts +2 -2
  252. package/src/values.ts +150 -79
package/src/evaluate.ts CHANGED
@@ -22,13 +22,27 @@ import {
22
22
  } from "./errors";
23
23
  import { EXIT_STATUS, setExitCode } from "./exit-codes";
24
24
  import { generateEvaluator } from "./codegen";
25
- import { countCoverage, getCoverageNode, runAtCoverageNode, type Coverage } from "./coverage";
25
+ import {
26
+ chargeContexts,
27
+ chargeFunctionConstruction,
28
+ chargeSetOperation,
29
+ costCoverage,
30
+ countCoverage,
31
+ createChargedEnumerator,
32
+ createProductSetEnumerator,
33
+ getCoverageNode,
34
+ runAtCoverageNode,
35
+ tagSubset,
36
+ type Coverage,
37
+ } from "./coverage";
26
38
  import { MESSAGE_CODE } from "./tlc/messages";
27
39
  import type { CheckerRuntime } from "./runtime";
28
40
  import {
29
- isConstantLevel,
41
+ isEvaluatedAtStartup,
42
+ isExpressionImpure,
30
43
  isImpureDefinition,
31
44
  isNonconstant,
45
+ isTlcEvalReached,
32
46
  type DefinitionFacts,
33
47
  } from "./dependencies";
34
48
  import { contextualApplications, substitutionFrames } from "./instances";
@@ -152,6 +166,7 @@ export interface Environment {
152
166
  variableIndex: Map<string, number>;
153
167
  facts: DefinitionFacts;
154
168
  startupValues: (Value | undefined)[];
169
+ tlcEvalValues: WeakMap<Expression, Value>;
155
170
  substitutedDefinitions: Set<Definition>;
156
171
  instanceParams: Set<OperatorParam>;
157
172
  evaluators: WeakMap<Expression, Evaluator>;
@@ -320,15 +335,14 @@ export const getDomainOperator = (expression: Expression) => (value: Value) => {
320
335
  };
321
336
 
322
337
  export const getSubsetOperator =
323
- (expression: Expression, builtin: Builtin) => (left: Value, right: Value) => {
338
+ (expression: Expression, subset: (left: Value, right: Value) => Value) =>
339
+ (left: Value, right: Value) => {
324
340
  if (!isSetValue(left) || isOverriddenSet(left)) {
325
341
  throw new TlaEvaluationError(
326
342
  `Attempted to evaluate an expression of form S \\subseteq T, but S was not enumerable.\n${describeRange(expression)}`,
327
343
  );
328
344
  }
329
- return builtin.evaluateBinary
330
- ? builtin.evaluateBinary(left, right)
331
- : builtin.evaluate([left, right]);
345
+ return subset(left, right);
332
346
  };
333
347
 
334
348
  export const createRealNumberError = (expression: DecimalExpression) =>
@@ -523,10 +537,13 @@ const someElement = (
523
537
  return false;
524
538
  };
525
539
 
526
- export const mapBoundSets = <Result>(bounds: Bound[], map: (set: Expression) => Result) =>
540
+ export const mapBoundSets = <Result>(
541
+ bounds: Bound[],
542
+ map: (set: Expression, index: number) => Result,
543
+ ) =>
527
544
  bounds.reduce<Result[]>((results, bound, index) => {
528
545
  results.push(
529
- index > 0 && bounds[index - 1].set === bound.set ? results[index - 1] : map(bound.set),
546
+ index > 0 && bounds[index - 1].set === bound.set ? results[index - 1] : map(bound.set, index),
530
547
  );
531
548
  return results;
532
549
  }, []);
@@ -557,6 +574,31 @@ export const forEachBinding = (
557
574
  visit: (scope: Scope | undefined) => boolean,
558
575
  ) => forEachBoundElement(bounds, getBoundElements(bounds, context), context.scope, visit);
559
576
 
577
+ const forEachChargedBinding = (
578
+ bounds: Bound[],
579
+ context: Context,
580
+ coverage: Coverage,
581
+ visit: (scope: Scope | undefined) => boolean,
582
+ ) => {
583
+ const bounded = mapBoundSets(bounds, (set) => {
584
+ const value = evaluate(set, context);
585
+ return {
586
+ value,
587
+ elements: getQuantifierElements(value, set, context.environment.runtime.version),
588
+ };
589
+ });
590
+ const sets = bounded.map((item) => item.elements);
591
+ const charge = chargeContexts(
592
+ coverage,
593
+ bounded.map((item) => item.value),
594
+ sets,
595
+ );
596
+ return forEachBoundElement(bounds, sets, context.scope, (scope) => {
597
+ charge();
598
+ return visit(scope);
599
+ });
600
+ };
601
+
560
602
  const getBoundsDomain = (bounds: Bound[], context: Context): Value => {
561
603
  const sets = mapBoundSets(bounds, (set) => evaluate(set, context));
562
604
  return sets.length === 1 ? sets[0] : { kind: "ProductSet", factors: sets };
@@ -615,12 +657,16 @@ export const bindLazyArguments = (
615
657
  typeof value.domain === "object" && value.domain.kind === "ProductSet"
616
658
  ? value.domain.factors
617
659
  : [];
618
- // Deviation from TLC: FcnLambdaValue#apply indexes past an argument tuple shorter than the bounds and ignores a longer one.
660
+ if (elements === undefined) {
661
+ throw new TlaEvaluationError(
662
+ `Attempted to apply a function to an argument not in its domain.\n${describeRange(expression.function)}`,
663
+ );
664
+ }
665
+ // Deviation from TLC: Tool#getFcnContext indexes past an argument tuple shorter than the bounds and ignores a longer one.
619
666
  const createListError = () =>
620
667
  new TlaEvaluationError(
621
668
  `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
669
  );
623
- if (elements === undefined) throw createListError();
624
670
  bounds.forEach((bound, index) => {
625
671
  if (index >= elements.length) throw createListError();
626
672
  const element = elements[index];
@@ -669,7 +715,7 @@ const getLazyFunctionTemplate = (bounds: Bound[], body: Expression) => {
669
715
  },
670
716
  ],
671
717
  ),
672
- body: formatRange(range),
718
+ body: describeNode(body),
673
719
  };
674
720
  };
675
721
 
@@ -793,14 +839,27 @@ const compileDefinitionBody = (definition: Definition, environment: Environment)
793
839
  return getEntryEvaluator(getDefinitionSource(definition), environment);
794
840
  };
795
841
 
842
+ const CALLER_SCOPE: Scope = {
843
+ name: "",
844
+ binding: { kind: "Value", value: false },
845
+ parent: undefined,
846
+ };
847
+
796
848
  const getDefinitionEvaluator = (definition: Definition, environment: Environment): Evaluator => {
797
849
  const compiled = environment.definitionEvaluators.get(definition);
798
850
  if (compiled) return compiled;
799
851
  const body = compileDefinitionBody(definition, environment);
800
852
  const definitionId = environment.facts.ids.get(definition);
801
853
  const startupValues = environment.startupValues;
802
- const evaluator: Evaluator =
803
- definitionId === undefined
854
+ const isInCallerContext =
855
+ definition.kind === "Operator" &&
856
+ definition.params.length === 0 &&
857
+ isTlcEvalReached(definition.body, environment);
858
+ const evaluator: Evaluator = isInCallerContext
859
+ ? (context) =>
860
+ (definitionId === undefined ? undefined : startupValues[definitionId]) ??
861
+ body(withScope(context, isTlcContextEmpty(context.scope) ? undefined : CALLER_SCOPE))
862
+ : definitionId === undefined
804
863
  ? (context) => body(withScope(context, undefined))
805
864
  : (context) => startupValues[definitionId] ?? body(withScope(context, undefined));
806
865
  environment.definitionEvaluators.set(definition, evaluator);
@@ -817,7 +876,7 @@ export const evaluateStartupDefinitions = (definitions: Definition[], environmen
817
876
  if (definition.kind === "Operator" && definition.params.length > 0) return;
818
877
  const name = definition.name;
819
878
  if (environment.constants.has(name) || environment.substitutions.has(name)) return;
820
- if (!isConstantLevel(definition, environment)) return;
879
+ if (!isEvaluatedAtStartup(definition, environment)) return;
821
880
  const definitionId = environment.facts.ids.get(definition);
822
881
  if (definitionId === undefined || environment.startupValues[definitionId] !== undefined) return;
823
882
  const context = { environment, scope: undefined, state: undefined, next: undefined };
@@ -969,6 +1028,7 @@ const isOperatorArgument = (expression: Expression, context: Context) => {
969
1028
  return operator !== undefined && getArity(operator) > 0;
970
1029
  };
971
1030
 
1031
+ // 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
1032
  const evaluateBuiltinArguments = (args: Expression[], context: Context) =>
973
1033
  args.map((arg) =>
974
1034
  isOperatorArgument(arg, context)
@@ -1113,7 +1173,15 @@ export const bindDefinitions = (
1113
1173
  node.parent = parent;
1114
1174
  return node;
1115
1175
  }, context.scope);
1116
- definitions.forEach((definition, index) => {
1176
+ let isRecursiveAtOrAfter = false;
1177
+ for (let index = definitions.length - 1; index >= 0; index--) {
1178
+ const definition = definitions[index];
1179
+ isRecursiveAtOrAfter ||= definition.isRecursive;
1180
+ // TLC's LET evaluates an operator without parameters in the context before it, which TLCEval#tlcEval tells from an empty one.
1181
+ const ownScope =
1182
+ definition.kind === "Operator" && definition.params.length === 0 && !isRecursiveAtOrAfter
1183
+ ? nodes[index].parent
1184
+ : scope;
1117
1185
  nodes[index].binding =
1118
1186
  definition.kind === "Function"
1119
1187
  ? {
@@ -1133,19 +1201,19 @@ export const bindDefinitions = (
1133
1201
  name: definition.name,
1134
1202
  params: definition.params,
1135
1203
  body: definition.body,
1136
- scope,
1204
+ scope: ownScope,
1137
1205
  },
1138
1206
  }
1139
1207
  : {
1140
1208
  kind: "Thunk",
1141
1209
  expression: definition.body,
1142
- scope,
1210
+ scope: ownScope,
1143
1211
  state: context.state,
1144
1212
  next: context.next,
1145
1213
  cache: undefined,
1146
1214
  isStreamed: reevaluated?.streamed.has(definition) ?? false,
1147
1215
  };
1148
- });
1216
+ }
1149
1217
  const coverage = context.environment.coverage;
1150
1218
  if (coverage && coverage.current !== -1) {
1151
1219
  nodes.forEach((node) => {
@@ -1175,16 +1243,22 @@ const evaluateLocalIdentifier = (name: string, expression: Expression, context:
1175
1243
  if (global?.kind === "Definition") {
1176
1244
  return getDefinitionEvaluator(global.definition, context.environment)(context);
1177
1245
  }
1178
- const builtin = context.environment.builtins.get(name);
1246
+ const builtin = context.environment.builtins.get(
1247
+ context.environment.substitutions.get(name) ?? name,
1248
+ );
1179
1249
  if (builtin?.arity === 0) return builtin.evaluate([], context);
1180
- throw new TlaEvaluationError(`Unknown identifier ${name} at ${describeLocation(expression)}`);
1250
+ throw new TlaEvaluationError(
1251
+ `In evaluation, the identifier ${name} is either undefined or not an operator.\n${describeRange(expression)}`,
1252
+ );
1181
1253
  };
1182
1254
 
1183
1255
  export const getReevaluatedDefinitions = (
1184
1256
  definitions: Definition[],
1185
1257
  environment: Environment,
1186
1258
  ): ReevaluatedDefinitions => ({
1187
- impure: new Set(definitions.filter((definition) => isImpureDefinition(definition, environment))),
1259
+ impure: new Set(
1260
+ definitions.filter((definition) => isImpureDefinition(definition, environment, "varying")),
1261
+ ),
1188
1262
  streamed: new Set(
1189
1263
  definitions.filter((definition) => isImpureDefinition(definition, environment, "streamed")),
1190
1264
  ),
@@ -1316,7 +1390,6 @@ const headFingerprint = (callStack: CallStack, source: Expression, error: unknow
1316
1390
 
1317
1391
  export const createTracingEnvironment = (environment: Environment): Environment => ({
1318
1392
  ...environment,
1319
- coverage: undefined,
1320
1393
  evaluators: new WeakMap(),
1321
1394
  entryEvaluators: new WeakMap(),
1322
1395
  definitionEvaluators: new WeakMap(),
@@ -1329,6 +1402,41 @@ export const createTracingEnvironment = (environment: Environment): Environment
1329
1402
  },
1330
1403
  });
1331
1404
 
1405
+ // TLC evaluates `a /\ b /\ c` as `(a /\ b) /\ c`, so its call stack holds each prefix.
1406
+ const compileTracedJunction = (
1407
+ expression: Expression & { kind: "And" | "Or" },
1408
+ operands: Evaluator[],
1409
+ callStack: CallStack | undefined,
1410
+ ): Evaluator | undefined => {
1411
+ const range = expression.location.range;
1412
+ const prefixEnds = expression.prefixEnds;
1413
+ if (!callStack || expression.isBulleted || !range || !prefixEnds || operands.length < 3) {
1414
+ return undefined;
1415
+ }
1416
+ const prefixes = prefixEnds
1417
+ .slice(0, operands.length - 2)
1418
+ .map((end) => ({
1419
+ ...expression,
1420
+ location: { ...expression.location, range: { ...range, end } },
1421
+ }))
1422
+ .reverse();
1423
+ const isAnd = expression.kind === "And";
1424
+ return (context) => {
1425
+ callStack.expressions.push(...prefixes);
1426
+ for (let index = 0; index < operands.length; index++) {
1427
+ if (index >= 2 && !callStack.isFrozen) callStack.expressions.pop();
1428
+ const value = operands[index](context);
1429
+ if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
1430
+ if (value !== isAnd) {
1431
+ if (!callStack.isFrozen)
1432
+ callStack.expressions.length -= prefixes.length - Math.max(index - 1, 0);
1433
+ return value;
1434
+ }
1435
+ }
1436
+ return isAnd;
1437
+ };
1438
+ };
1439
+
1332
1440
  const traceFrames =
1333
1441
  (
1334
1442
  expression: Expression,
@@ -1356,9 +1464,21 @@ const countEvaluator =
1356
1464
  coverage.current = node;
1357
1465
  try {
1358
1466
  const value = evaluator(context);
1359
- if (typeof value === "object" && expression.kind === "SetEnumeration") {
1360
- coverage.values.set(value, node);
1361
- }
1467
+ const isTagged =
1468
+ expression.kind === "SetEnumeration" ||
1469
+ ((expression.kind === "SetFilter" || expression.kind === "SetMap") &&
1470
+ isReducibleSet(value)) ||
1471
+ (expression.kind === "SetFilter" &&
1472
+ typeof value === "object" &&
1473
+ value.kind === "FilteredSet") ||
1474
+ ((expression.kind === "FunctionSet" || expression.kind === "RecordSet") &&
1475
+ typeof value === "object" &&
1476
+ value.kind === expression.kind) ||
1477
+ (expression.kind === "Apply" &&
1478
+ expression.operator === "SUBSET" &&
1479
+ typeof value === "object" &&
1480
+ value.kind === "Subset");
1481
+ if (typeof value === "object" && isTagged) coverage.values.set(value, node);
1362
1482
  return value;
1363
1483
  } finally {
1364
1484
  coverage.current = outer;
@@ -1508,6 +1628,26 @@ const compileClosureCall = (
1508
1628
  };
1509
1629
  };
1510
1630
 
1631
+ // TLC's LET conses only its arity-0 definitions onto the context that TLCEval#tlcEval caches under when it is empty.
1632
+ const isTlcContextEmpty = (scope: Scope | undefined) => {
1633
+ for (let node = scope; node !== undefined; node = node.parent) {
1634
+ const binding = node.binding;
1635
+ if (
1636
+ binding.kind !== "Operator" ||
1637
+ binding.operator.kind !== "Closure" ||
1638
+ binding.operator.params.length === 0
1639
+ ) {
1640
+ return false;
1641
+ }
1642
+ let letScope = binding.operator.scope;
1643
+ while (letScope !== undefined && letScope !== node) letScope = letScope.parent;
1644
+ if (letScope !== node) return false;
1645
+ }
1646
+ return true;
1647
+ };
1648
+
1649
+ const SET_OPERATORS = new Set(["\\cup", "\\cap", "\\"]);
1650
+
1511
1651
  const compileApply = (
1512
1652
  expression: Expression & { kind: "Apply" },
1513
1653
  environment: Environment,
@@ -1547,19 +1687,63 @@ const compileApply = (
1547
1687
  return (context) => domain(operand(context));
1548
1688
  }
1549
1689
  if (global?.kind === "Builtin" && global.name === "TLCEval" && args.length === 1) {
1690
+ // Deviation from TLC: TLCEval#tlcEval evaluates an argument SANY takes for constant, such as Print(v, TRUE), in an empty state.
1550
1691
  const isCached =
1551
1692
  !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
- );
1693
+ const tlcEvalValues = environment.tlcEvalValues;
1694
+ return (context) => {
1695
+ if (!isCached || !isTlcContextEmpty(context.scope)) {
1696
+ return global.evaluate(getLazyArguments(args, context), context);
1697
+ }
1698
+ const cached = tlcEvalValues.get(expression);
1699
+ if (cached !== undefined) return cached;
1700
+ const value = global.evaluate(getLazyArguments(args, context), undefined);
1701
+ tlcEvalValues.set(expression, value);
1702
+ return value;
1703
+ };
1557
1704
  }
1558
- if (global?.kind === "Builtin" && global.name === "\\subseteq" && args.length === 2) {
1705
+ if (
1706
+ global?.kind === "Builtin" &&
1707
+ global.name === "\\subseteq" &&
1708
+ global.evaluateBinary &&
1709
+ args.length === 2
1710
+ ) {
1559
1711
  const left = getEvaluator(args[0], environment);
1560
1712
  const right = getEvaluator(args[1], environment);
1561
- const subset = getSubsetOperator(expression, global);
1562
- return (context) => subset(left(context), right(context));
1713
+ const subset = getSubsetOperator(expression, global.evaluateBinary);
1714
+ const coverage = environment.coverage;
1715
+ if (!coverage) return (context) => subset(left(context), right(context));
1716
+ return (context) => {
1717
+ const leftValue = left(context);
1718
+ const rightValue = right(context);
1719
+ if (
1720
+ typeof leftValue !== "object" ||
1721
+ leftValue.kind !== "Set" ||
1722
+ !coverage.values.has(leftValue)
1723
+ ) {
1724
+ return subset(leftValue, rightValue);
1725
+ }
1726
+ const missing = leftValue.elements.findIndex((element) => !isElementOf(element, rightValue));
1727
+ costCoverage(coverage, leftValue, (missing === -1 ? leftValue.elements.length : missing) + 1);
1728
+ return missing === -1;
1729
+ };
1730
+ }
1731
+ const coverage = environment.coverage;
1732
+ const combine = global?.kind === "Builtin" ? global.evaluateBinary : undefined;
1733
+ if (coverage && combine && SET_OPERATORS.has(expression.operator) && args.length === 2) {
1734
+ const left = getEvaluator(args[0], environment);
1735
+ const right = getEvaluator(args[1], environment);
1736
+ return (context) => {
1737
+ const leftValue = left(context);
1738
+ const rightValue = right(context);
1739
+ return chargeSetOperation(
1740
+ coverage,
1741
+ expression.operator,
1742
+ leftValue,
1743
+ rightValue,
1744
+ combine(leftValue, rightValue),
1745
+ );
1746
+ };
1563
1747
  }
1564
1748
  if (global?.kind === "Builtin") return compileBuiltinCall(global, args, environment);
1565
1749
  if (expression.operator === "\\cdot" && args.length === 2) {
@@ -1592,6 +1776,18 @@ const compileQuantifier = (
1592
1776
  const isForall = expression.kind === "Forall";
1593
1777
  const body = getEvaluator(expression.body, environment);
1594
1778
  const bound = expression.bounds[0];
1779
+ const coverage = environment.coverage;
1780
+ if (coverage) {
1781
+ return (context) => {
1782
+ const isFound = forEachChargedBinding(
1783
+ expression.bounds,
1784
+ context,
1785
+ coverage,
1786
+ (scope) => expectBooleanBody(body(withScope(context, scope)), expression) !== isForall,
1787
+ );
1788
+ return isFound ? !isForall : isForall;
1789
+ };
1790
+ }
1595
1791
  if (expression.bounds.length === 1 && bound.pattern.kind === "Name") {
1596
1792
  const name = bound.pattern.name;
1597
1793
  const set = getEvaluator(bound.set, environment);
@@ -1717,8 +1913,14 @@ export const getFunctionBuilder = (
1717
1913
  return markLambdaFunction(functionValue);
1718
1914
  }
1719
1915
  const pairs: [Value, Value][] = [];
1720
- const sets = mapBoundSets(bounds, (set) =>
1721
- getNormalizedElements(evaluate(set, context), set, context.environment.runtime.version),
1916
+ const sets = mapBoundSets(bounds, (set, index) =>
1917
+ getNormalizedElements(
1918
+ bounds.length > 1 && typeof domain === "object" && domain.kind === "ProductSet"
1919
+ ? domain.factors[index]
1920
+ : domain,
1921
+ set,
1922
+ context.environment.runtime.version,
1923
+ ),
1722
1924
  );
1723
1925
  forEachBoundElement(bounds, sets, context.scope, (scope) => {
1724
1926
  const key =
@@ -1733,13 +1935,22 @@ export const getFunctionBuilder = (
1733
1935
  const template = getLazyFunctionTemplate(bounds, expression.body);
1734
1936
  const boundTupleLengths = getBoundTupleLengths(bounds);
1735
1937
  const bodyNames = getScopeNames(expression.body);
1938
+ const coverage = environment.coverage;
1736
1939
  const createLazy = (domain: Value, context: Context) => {
1737
1940
  const scope = trimScope(context.scope, bodyNames);
1738
1941
  const lambdaContext = withScope(context, scope);
1942
+ const compute = (argument: Value) =>
1943
+ body(withScope(lambdaContext, bindArgument(bounds, scope, argument)));
1944
+ const node = coverage && !environment.callStack ? coverage.current : -1;
1739
1945
  const functionValue = keepLambda({
1740
1946
  value: createLazyFunction(
1741
1947
  domain,
1742
- (argument) => body(withScope(lambdaContext, bindArgument(bounds, scope, argument))),
1948
+ coverage
1949
+ ? (argument) =>
1950
+ coverage.current === -1
1951
+ ? compute(argument)
1952
+ : runAtCoverageNode(coverage, node, () => compute(argument))
1953
+ : compute,
1743
1954
  getLazyFunctionSource(template, bounds, domain),
1744
1955
  boundTupleLengths,
1745
1956
  ),
@@ -1791,6 +2002,23 @@ const compileFunctionConstruction = (
1791
2002
  ): Evaluator => {
1792
2003
  const build = getFunctionBuilder(expression, environment).build;
1793
2004
  const bounds = expression.bounds;
2005
+ const coverage = environment.coverage;
2006
+ if (coverage) {
2007
+ return (context) => {
2008
+ const domain = getBoundsDomain(bounds, context);
2009
+ const value = build(domain, context);
2010
+ const sets =
2011
+ bounds.length === 1 || typeof domain !== "object" || domain.kind !== "ProductSet"
2012
+ ? [domain]
2013
+ : domain.factors;
2014
+ const isConverted =
2015
+ (typeof value !== "object" || value.kind !== "LazyFunction") && sets.every(isReducibleSet);
2016
+ if (isConverted && coverage.current !== -1 && coverage.covered.has(expression)) {
2017
+ chargeFunctionConstruction(coverage, coverage.current, sets);
2018
+ }
2019
+ return value;
2020
+ };
2021
+ }
1794
2022
  if (bounds.length === 1 && bounds[0].pattern.kind === "Name") {
1795
2023
  const set = getEvaluator(bounds[0].set, environment);
1796
2024
  return (context) => build(set(context), context);
@@ -1864,29 +2092,19 @@ export const getLazyFilter = (
1864
2092
  ) => {
1865
2093
  const predicate = getEvaluator(expression.predicate, environment);
1866
2094
  const pattern = expression.bound.pattern;
1867
- const range = expression.predicate.location.range;
1868
- const source = range && {
2095
+ const predicateNode = describeNode(expression.predicate);
2096
+ const source = expression.predicate.location.range && {
1869
2097
  names: pattern.kind === "Name" ? pattern.name : pattern.names.join(", "),
1870
- predicate: formatRange(range),
2098
+ predicate: predicateNode,
1871
2099
  };
1872
- const predicateNode = describeNode(expression.predicate);
1873
2100
  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
2101
  const createFiltered = (
1882
2102
  base: Value,
1883
2103
  context: Context,
1884
2104
  evaluator: Evaluator,
1885
2105
  node: number,
1886
- ): RebindableFilteredSet => ({
1887
- kind: "FilteredSet",
1888
- base,
1889
- test: (element, isMember) => {
2106
+ ): RebindableFilteredSet => {
2107
+ const test = (element: Value, isMember: boolean) => {
1890
2108
  if (
1891
2109
  pattern.kind === "Tuple" &&
1892
2110
  getSequenceElements(element)?.length !== pattern.names.length
@@ -1895,29 +2113,60 @@ export const getLazyFilter = (
1895
2113
  `Attempted to check if the value:\n${prettyPrint(formatValue(element))}\nis an element of a set of ${pattern.names.length}-tuples.`,
1896
2114
  );
1897
2115
  }
1898
- const value = testCovered(node, isMember, () =>
1899
- evaluator(withScope(context, bindPattern(context.scope, pattern, element))),
1900
- );
2116
+ const value = evaluator(withScope(context, bindPattern(context.scope, pattern, element)));
1901
2117
  if (typeof value !== "boolean") {
1902
2118
  throw new TlaEvaluationError(
1903
2119
  `${isMember ? "The evaluation of predicate" : "Evaluating predicate"} ${predicateNode} yielded non-Boolean value.`,
1904
2120
  );
1905
2121
  }
1906
2122
  return value;
1907
- },
1908
- source,
1909
- rebind: (tracing) =>
2123
+ };
2124
+ const rebind = (tracing: Environment) =>
1910
2125
  createFiltered(
1911
2126
  base,
1912
2127
  { ...context, environment: tracing },
1913
2128
  getEvaluator(expression.predicate, tracing),
1914
2129
  -1,
1915
- ),
1916
- });
2130
+ );
2131
+ if (!coverage || node === -1) return { kind: "FilteredSet", base, test, source, rebind };
2132
+ return {
2133
+ kind: "FilteredSet",
2134
+ base,
2135
+ test: (element, isMember) =>
2136
+ runAtCoverageNode(coverage, isMember ? -1 : node, () => test(element, isMember)),
2137
+ startPass: (isMaterialized) => {
2138
+ const draws = createProductSetEnumerator(coverage, base);
2139
+ return (element) => {
2140
+ draws?.next();
2141
+ tagSubset(coverage, base, element);
2142
+ coverage.secondary[node]++;
2143
+ const value = runAtCoverageNode(coverage, node, () => test(element, false));
2144
+ if (isMaterialized && value) coverage.secondary[node]++;
2145
+ return value;
2146
+ };
2147
+ },
2148
+ source,
2149
+ rebind,
2150
+ };
2151
+ };
1917
2152
  return (base: Value, context: Context, node = -1) =>
1918
2153
  createFiltered(base, context, predicate, node);
1919
2154
  };
1920
2155
 
2156
+ const hasLocalName = (expression: Expression): boolean =>
2157
+ isLocallyResolved(expression) ||
2158
+ expression.kind === "OperatorReference" ||
2159
+ getChildren(expression).some(hasLocalName);
2160
+
2161
+ export const isUniformPredicate = (
2162
+ expression: Expression & { kind: "SetFilter" },
2163
+ environment: Environment,
2164
+ ) =>
2165
+ expression.bound.pattern.kind === "Name" &&
2166
+ !environment.coverage &&
2167
+ !hasLocalName(expression.predicate) &&
2168
+ !isExpressionImpure([expression.predicate], environment, "varying");
2169
+
1921
2170
  export const expectFilterPredicate = (
1922
2171
  value: Value,
1923
2172
  expression: Expression & { kind: "SetFilter" },
@@ -1960,32 +2209,34 @@ const compileSetComprehension = (
1960
2209
  const filterLazily = getLazyFilter(expression, environment);
1961
2210
  const pattern = expression.bound.pattern;
1962
2211
  const coverage = environment.coverage;
2212
+ const isUniform = isUniformPredicate(expression, environment);
1963
2213
  return (context) => {
1964
2214
  const base = set(context);
1965
2215
  if (!isReducibleSet(base)) return filterLazily(base, context, coverage?.current);
1966
2216
  const kept: Value[] = [];
1967
- const visit = (element: Value) => {
2217
+ const elements = base.kind === "Interval" ? base : toFiniteSet(base).elements;
2218
+ const size = Array.isArray(elements) ? elements.length : elements.high - elements.low + 1;
2219
+ for (let position = 0; position < size; position++) {
2220
+ const element = Array.isArray(elements) ? elements[position] : elements.low + position;
1968
2221
  const value = predicate(withScope(context, bindPattern(context.scope, pattern, element)));
1969
2222
  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;
2223
+ else if (isUniform) break;
1977
2224
  }
2225
+ if (coverage) costCoverage(coverage, base, size + 1);
1978
2226
  return createNormalizedSet(kept);
1979
2227
  };
1980
2228
  }
1981
2229
  if (expression.kind === "SetMap") {
1982
2230
  const mapped = getEvaluator(expression.expression, environment);
2231
+ const coverage = environment.coverage;
1983
2232
  return (context) => {
1984
2233
  const elements: Value[] = [];
1985
- forEachBinding(expression.bounds, context, (scope) => {
2234
+ const add = (scope: Scope | undefined) => {
1986
2235
  addBoundedElement(elements, mapped(withScope(context, scope)));
1987
2236
  return false;
1988
- });
2237
+ };
2238
+ if (coverage) forEachChargedBinding(expression.bounds, context, coverage, add);
2239
+ else forEachBinding(expression.bounds, context, add);
1989
2240
  return createEnumeratedSet(elements);
1990
2241
  };
1991
2242
  }
@@ -1999,16 +2250,15 @@ const compileSetComprehension = (
1999
2250
  }
2000
2251
  const body = getEvaluator(expression.body, environment);
2001
2252
  const evaluateSet = getEvaluator(set, environment);
2253
+ const coverage = environment.coverage;
2002
2254
  return (context) => {
2003
- const elements = getChoiceElements(
2004
- evaluateSet(context),
2005
- expression,
2006
- set,
2007
- context.environment.runtime.version,
2008
- );
2255
+ const base = evaluateSet(context);
2256
+ const elements = getChoiceElements(base, expression, set, context.environment.runtime.version);
2257
+ const enumerator = coverage && createChargedEnumerator(coverage, base, elements, true);
2009
2258
  let chosen: Value | undefined;
2010
2259
  const pattern = expression.pattern;
2011
2260
  someElement(elements, (element) => {
2261
+ enumerator?.next();
2012
2262
  if (
2013
2263
  pattern.kind === "Tuple" &&
2014
2264
  getSequenceElements(element)?.length !== pattern.names.length
@@ -2022,8 +2272,9 @@ const compileSetComprehension = (
2022
2272
  chosen = getBoundValue(pattern, scope);
2023
2273
  return true;
2024
2274
  });
2025
- if (chosen === undefined) throw createNoChoiceError(expression);
2026
- return chosen;
2275
+ if (chosen !== undefined) return chosen;
2276
+ enumerator?.next();
2277
+ throw createNoChoiceError(expression);
2027
2278
  };
2028
2279
  };
2029
2280
 
@@ -2035,20 +2286,21 @@ export const hasDuplicateFields = (sortedFields: RecordField[]) =>
2035
2286
 
2036
2287
  const compileRecord = (recordFields: RecordField[], environment: Environment): Evaluator => {
2037
2288
  const fields = getSortedFields(recordFields);
2038
- const hasDuplicates = hasDuplicateFields(fields);
2039
- const values = fields.map((field) => getEvaluator(field.value, environment));
2040
- if (hasDuplicates) {
2289
+ const values = recordFields.map((field) => getEvaluator(field.value, environment));
2290
+ if (hasDuplicateFields(fields)) {
2041
2291
  return (context) =>
2042
2292
  createRecord(
2043
- fields.map((field, index): [string, Value] => [field.name, values[index](context)]),
2293
+ recordFields.map((field, index): [string, Value] => [field.name, values[index](context)]),
2044
2294
  );
2045
2295
  }
2046
2296
  const names = fields.map((field) => field.name);
2047
2297
  const writtenNames = recordFields.map((field) => field.name);
2048
2298
  if (writtenNames.some((name, index) => name !== names[index])) {
2299
+ const writtenIndexes = fields.map((field) => recordFields.indexOf(field));
2049
2300
  return (context) =>
2050
2301
  createWrittenRecord(
2051
2302
  names,
2303
+ writtenIndexes,
2052
2304
  values.map((value) => value(context)),
2053
2305
  writtenNames,
2054
2306
  );
@@ -2098,25 +2350,31 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2098
2350
  };
2099
2351
  case "And": {
2100
2352
  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
- };
2353
+ return (
2354
+ compileTracedJunction(expression, operands, environment.callStack) ??
2355
+ ((context) => {
2356
+ for (let index = 0; index < operands.length; index++) {
2357
+ const value = operands[index](context);
2358
+ if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
2359
+ if (!value) return false;
2360
+ }
2361
+ return true;
2362
+ })
2363
+ );
2109
2364
  }
2110
2365
  case "Or": {
2111
2366
  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
- };
2367
+ return (
2368
+ compileTracedJunction(expression, operands, environment.callStack) ??
2369
+ ((context) => {
2370
+ for (let index = 0; index < operands.length; index++) {
2371
+ const value = operands[index](context);
2372
+ if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
2373
+ if (value) return true;
2374
+ }
2375
+ return false;
2376
+ })
2377
+ );
2120
2378
  }
2121
2379
  case "Prime": {
2122
2380
  const inner = getChildEvaluator(expression.expression);
@@ -2202,8 +2460,19 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2202
2460
  case "RecordSet": {
2203
2461
  const fields = getSortedFields(expression.fields);
2204
2462
  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)) });
2463
+ const writtenIndexes = fields.map((field) => expression.fields.indexOf(field));
2464
+ const sets = expression.fields.map((field) => getChildEvaluator(field.value));
2465
+ if (writtenIndexes.every((writtenIndex, index) => writtenIndex === index)) {
2466
+ return (context) => ({ kind: "RecordSet", names, sets: sets.map((set) => set(context)) });
2467
+ }
2468
+ return (context) => {
2469
+ const writtenSets = sets.map((set) => set(context));
2470
+ return {
2471
+ kind: "RecordSet",
2472
+ names,
2473
+ sets: writtenIndexes.map((index) => writtenSets[index]),
2474
+ };
2475
+ };
2207
2476
  }
2208
2477
  case "Except":
2209
2478
  return compileExcept(expression, environment);
@@ -2270,6 +2539,8 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2270
2539
  }
2271
2540
  case "Label":
2272
2541
  return getChildEvaluator(expression.body);
2542
+ case "Selection":
2543
+ return getChildEvaluator(expression.expression);
2273
2544
  case "Subexpression":
2274
2545
  return () => {
2275
2546
  throw new TlaEvaluationError(