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
@@ -472,7 +472,11 @@ const printSuccess = (printer: MessagePrinter, optimistic: number, actual: numbe
472
472
  ].join("\n"),
473
473
  );
474
474
 
475
- export const printDepthFirst = (printer: MessagePrinter, output: DepthFirstOutput) => {
475
+ export const printDepthFirst = (
476
+ printer: MessagePrinter,
477
+ output: DepthFirstOutput,
478
+ startTime: number,
479
+ ) => {
476
480
  switch (output.kind) {
477
481
  case "message":
478
482
  printer.print(
@@ -481,6 +485,9 @@ export const printDepthFirst = (printer: MessagePrinter, output: DepthFirstOutpu
481
485
  printer.isTool ? output.toolMessage : output.message,
482
486
  );
483
487
  return;
488
+ case "coverage":
489
+ printCoverage(printer, output.coverage, startTime);
490
+ return;
484
491
  case "behavior":
485
492
  output.states.forEach((state, index) =>
486
493
  output.isInvariant
@@ -548,6 +555,7 @@ export const printResult = (result: CheckResult, printer: MessagePrinter, timing
548
555
  printTrace(printer, failure.trace, "error-trace");
549
556
  const traceFailure = failure.traceFailure;
550
557
  if (traceFailure) {
558
+ printTraceOutput(printer, traceFailure.output);
551
559
  print(
552
560
  traceFailure.code,
553
561
  MESSAGE_LEVEL.error,
@@ -634,7 +642,11 @@ export const printStartupBanner = (printer: MessagePrinter, args: TlcArguments)
634
642
  );
635
643
  };
636
644
 
637
- export const printSimulation = (printer: MessagePrinter, output: SimulationOutput) => {
645
+ export const printSimulation = (
646
+ printer: MessagePrinter,
647
+ output: SimulationOutput,
648
+ startTime: number,
649
+ ) => {
638
650
  const print = printer.print;
639
651
  switch (output.kind) {
640
652
  case "message":
@@ -644,6 +656,9 @@ export const printSimulation = (printer: MessagePrinter, output: SimulationOutpu
644
656
  printer.isTool ? output.toolMessage : output.message,
645
657
  );
646
658
  return;
659
+ case "coverage":
660
+ printCoverage(printer, output.coverage, startTime);
661
+ return;
647
662
  case "behavior": {
648
663
  const last = output.trace[output.trace.length - 1];
649
664
  if (!output.isLastStateOnly) {
package/src/cli/tlc.ts CHANGED
@@ -280,8 +280,9 @@ const checkSpec = async (
280
280
  } else {
281
281
  printError(error, printer);
282
282
  }
283
- printFinished();
284
- return getTopLevelExitCode(error);
283
+ const exitCode = getTopLevelExitCode(error);
284
+ if (exitCode !== EXIT_STATUS.abort) printFinished();
285
+ return exitCode;
285
286
  };
286
287
  const config = (() => {
287
288
  try {
@@ -439,7 +440,7 @@ const checkSpec = async (
439
440
  aril: args.aril,
440
441
  isGenerating: args.mode === "generate",
441
442
  scheduler: args.scheduler,
442
- onSimulation: (output) => printSimulation(printer, output),
443
+ onSimulation: (output) => printSimulation(printer, output, timing.startTime),
443
444
  });
444
445
  printFinished();
445
446
  return status;
@@ -448,7 +449,7 @@ const checkSpec = async (
448
449
  const status = checkDepthFirst({
449
450
  ...options,
450
451
  maxDepth: args.dfidDepth,
451
- onOutput: (output) => printDepthFirst(printer, output),
452
+ onOutput: (output) => printDepthFirst(printer, output, timing.startTime),
452
453
  });
453
454
  printFinished();
454
455
  return status;
@@ -52,7 +52,7 @@ const XML_EXPORT_USAGE = (() => {
52
52
  "",
53
53
  getBold("OPTIONS"),
54
54
  "",
55
- ...options.map(([flag, description]) => `\t${getBold(flag)}\n\t\t${description}`),
55
+ ...options.map((option) => `\t${getBold(option[0])}\n\t\t${option[1]}`),
56
56
  "",
57
57
  getBold("TIPS"),
58
58
  "",
package/src/codegen.ts CHANGED
@@ -1,4 +1,5 @@
1
1
  import { getChildren, getReferencedName, isLocallyResolved, type Expression } from "./ast";
2
+ import { isTlcEvalReached } from "./dependencies";
2
3
  import {
3
4
  bindValue,
4
5
  expectBooleanBody,
@@ -14,6 +15,7 @@ import {
14
15
  getFunctionBuilder,
15
16
  getLazyFilter,
16
17
  isKeptLazy,
18
+ isUniformPredicate,
17
19
  getDomainOperator,
18
20
  getSubsetOperator,
19
21
  getEvaluator,
@@ -161,19 +163,26 @@ const createLocal = (generator: Generator) => `local${generator.counter++}`;
161
163
  const getFreeNames = (expression: Expression, names = new Set<string>()) => {
162
164
  const name = getReferencedName(expression);
163
165
  if (name !== undefined) names.add(name);
164
- getChildren(expression).forEach((child) => getFreeNames(child, names));
166
+ if (expression.kind !== "Selection") {
167
+ getChildren(expression).forEach((child) => getFreeNames(child, names));
168
+ }
165
169
  return names;
166
170
  };
167
171
 
168
172
  const getDelegateContext = (generator: Generator, expression: Expression, frame: Frame) => {
173
+ if (frame.locals.size === 0) return frame.context;
174
+ // TLC caches a constant TLCEval only where no name is bound, so a delegate that reaches one sees every local.
175
+ const isEveryLocalCaptured = isTlcEvalReached(expression, generator.environment);
169
176
  const freeNames = getFreeNames(expression);
170
- const captured = [...frame.locals].filter(([name]) => freeNames.has(name));
177
+ const captured = [...frame.locals].filter(
178
+ (entry) => isEveryLocalCaptured || freeNames.has(entry[0]),
179
+ );
171
180
  if (captured.length === 0) return frame.context;
172
181
  const names = addReference(
173
182
  generator,
174
- captured.map(([name]) => name),
183
+ captured.map((entry) => entry[0]),
175
184
  );
176
- return `extend(${frame.context}, ${names}, [${captured.map(([, local]) => local).join(", ")}])`;
185
+ return `extend(${frame.context}, ${names}, [${captured.map((entry) => entry[1]).join(", ")}])`;
177
186
  };
178
187
 
179
188
  const generateDelegate = (generator: Generator, expression: Expression, frame: Frame) =>
@@ -267,7 +276,8 @@ const generateSetFilter = (
267
276
  const lazy = `if (!isReducible(${base})) return ${filterLazily}(${base}, ${getDelegateContext(generator, expression, bodyFrame)});`;
268
277
  const set = generateExpression(generator, expression.bound.set, bodyFrame);
269
278
  bodyFrame.locals.set(name, element);
270
- const test = `if (filterPredicate(${generateExpression(generator, expression.predicate, bodyFrame)}, ${node})) addBounded(${kept}, ${element});`;
279
+ const stop = isUniformPredicate(expression, generator.environment) ? " else break;" : "";
280
+ const test = `if (filterPredicate(${generateExpression(generator, expression.predicate, bodyFrame)}, ${node})) addBounded(${kept}, ${element});${stop}`;
271
281
  return `const ${base} = ${set}; ${lazy} const ${list} = ${base}.kind === "Interval" ? ${base} : finiteElements(${base}); const ${kept} = []; ${generateLoop(generator, list, element, test)} return normalizedSet(${kept});`;
272
282
  });
273
283
 
@@ -318,9 +328,8 @@ const generateApply = (
318
328
  const domain = addReference(generator, getDomainOperator(expression));
319
329
  return `${domain}(${generateExpression(generator, args[0], frame)})`;
320
330
  }
321
- if (builtin.name === "TLCEval") return generateDelegate(generator, expression, frame);
322
- if (builtin.name === "\\subseteq" && args.length === 2) {
323
- const subset = addReference(generator, getSubsetOperator(expression, builtin));
331
+ if (builtin.name === "\\subseteq" && builtin.evaluateBinary && args.length === 2) {
332
+ const subset = addReference(generator, getSubsetOperator(expression, builtin.evaluateBinary));
324
333
  return `${subset}(${generateExpression(generator, args[0], frame)}, ${generateExpression(generator, args[1], frame)})`;
325
334
  }
326
335
  const environment = generator.environment;
@@ -440,12 +449,16 @@ const generateExpression = (generator: Generator, expression: Expression, frame:
440
449
  generator,
441
450
  fields.map((field) => field.name),
442
451
  );
443
- const values = `[${fields.map((field) => generate(field.value)).join(", ")}]`;
452
+ const values = `[${expression.fields.map((field) => generate(field.value)).join(", ")}]`;
444
453
  const writtenNames = expression.fields.map((field) => field.name);
445
454
  if (writtenNames.every((name, index) => name === fields[index].name)) {
446
455
  return `record(${names}, ${values})`;
447
456
  }
448
- return `writtenRecord(${names}, ${values}, ${addReference(generator, writtenNames)})`;
457
+ const writtenIndexes = addReference(
458
+ generator,
459
+ fields.map((field) => expression.fields.indexOf(field)),
460
+ );
461
+ return `writtenRecord(${names}, ${writtenIndexes}, ${values}, ${addReference(generator, writtenNames)})`;
449
462
  }
450
463
  case "Tuple":
451
464
  return `tuple([${expression.elements.map((element) => generate(element)).join(", ")}])`;
package/src/coverage.ts CHANGED
@@ -1,4 +1,5 @@
1
1
  import {
2
+ getFunctionConstruction,
2
3
  isLocallyResolved,
3
4
  type Bound,
4
5
  type Definition,
@@ -7,10 +8,17 @@ import {
7
8
  type SourceRange,
8
9
  } from "./ast";
9
10
  import { formatRange } from "./errors";
11
+ import { SELECTION_NAME } from "./resolve";
10
12
  import type { Environment, Scope } from "./evaluate";
11
13
  import { getJavaHashCode } from "./java-hash";
12
14
  import { getTlcFingerprint } from "./tlc/fingerprint";
13
- import type { Value } from "./values";
15
+ import {
16
+ getCardinality,
17
+ isEmptySet,
18
+ isReducibleSet,
19
+ type IntervalValue,
20
+ type Value,
21
+ } from "./values";
14
22
 
15
23
  export type CoverageKind = "init" | "next" | "invariant" | "constraint" | "implied";
16
24
 
@@ -49,6 +57,11 @@ export interface CoverageReport {
49
57
  relations: CoverageRelationReport[];
50
58
  }
51
59
 
60
+ export interface CoverageOutput {
61
+ kind: "coverage";
62
+ coverage: CoverageReport;
63
+ }
64
+
52
65
  interface CoverageVariable {
53
66
  label: string;
54
67
  distinct: number;
@@ -81,6 +94,8 @@ interface Resolved {
81
94
  scope: Local | undefined;
82
95
  }
83
96
 
97
+ export const letDefinitions = new WeakMap<Scope, Definition>();
98
+
84
99
  const STANDARD_MODULES = new Set([
85
100
  "FiniteSets",
86
101
  "Sequences",
@@ -118,6 +133,17 @@ export const createCoverage = (variableCount: number): Coverage => ({
118
133
  relations: [],
119
134
  });
120
135
 
136
+ export const createCoverageEnvironment = (
137
+ environment: Environment,
138
+ coverage: Coverage,
139
+ ): Environment => ({
140
+ ...environment,
141
+ evaluators: new WeakMap(),
142
+ entryEvaluators: new WeakMap(),
143
+ definitionEvaluators: new WeakMap(),
144
+ coverage,
145
+ });
146
+
121
147
  const addNode = (
122
148
  coverage: Coverage,
123
149
  expression: Expression | undefined,
@@ -154,6 +180,10 @@ const findCoverageRelation = (coverage: Coverage, kind: CoverageKind, expression
154
180
  (relation) => relation.kind === kind && relation.expression === expression,
155
181
  )?.node;
156
182
 
183
+ const getRelationRange = (expression: Expression) =>
184
+ expression.location.range ??
185
+ (expression.kind === "Let" ? expression.body.location.range : undefined);
186
+
157
187
  export const addCoverageRelation = (
158
188
  coverage: Coverage,
159
189
  kind: CoverageKind,
@@ -163,7 +193,7 @@ export const addCoverageRelation = (
163
193
  ) => {
164
194
  const shared = kind === "next" ? findCoverageRelation(coverage, kind, expression) : undefined;
165
195
  if (shared !== undefined) return shared;
166
- const node = addNode(coverage, undefined, expression.location.range, -1, false);
196
+ const node = addNode(coverage, undefined, getRelationRange(expression), -1, false);
167
197
  coverage.relations.push({ kind, label, expression, scope, node });
168
198
  return node;
169
199
  };
@@ -184,9 +214,9 @@ export const getCoverageLabel = (
184
214
  ) => {
185
215
  const definition = name === undefined ? undefined : environment.definitions.get(name);
186
216
  const head = definition?.kind === "Operator" ? definition.head : undefined;
187
- const range = expression.location.range;
217
+ const range = getRelationRange(expression);
188
218
  if (!definition || !head) return `Action ${range ? formatRange(range) : "Unknown location"}`;
189
- if (isSameRange(definition.body.location.range, range) || !range) {
219
+ if (isSameRange(getRelationRange(definition.body), range) || !range) {
190
220
  return `${definition.name} ${formatRange(head)}`;
191
221
  }
192
222
  return `${definition.name} ${formatRange(head)} (${range.start.line} ${range.start.column} ${range.end.line} ${range.end.column})`;
@@ -233,6 +263,15 @@ const bindNames = (names: string[], locals: Local | undefined) =>
233
263
  locals,
234
264
  );
235
265
 
266
+ const bindLocalDefinitions = (definitions: Definition[], locals: Local | undefined) => {
267
+ const inner = definitions.reduce<Local | undefined>(
268
+ (parent, definition) => ({ name: definition.name, definition, scope: undefined, parent }),
269
+ locals,
270
+ );
271
+ for (let local = inner; local !== locals && local; local = local.parent) local.scope = inner;
272
+ return inner;
273
+ };
274
+
236
275
  const getBoundNames = (bounds: Bound[]) =>
237
276
  bounds.flatMap((bound) =>
238
277
  bound.pattern.kind === "Name" ? [bound.pattern.name] : bound.pattern.names,
@@ -302,10 +341,13 @@ export const buildCoverage = (
302
341
  definition.kind === "Function"
303
342
  ? getBoundNames(definition.bounds)
304
343
  : definition.params.map((param) => param.name);
305
- walk(definition.body, bindNames(names, resolved.scope));
306
344
  if (definition.kind === "Function") {
307
- getBoundSets(definition.bounds).forEach((set) => walk(set, resolved.scope));
308
- }
345
+ const isLet = resolved.scope !== undefined;
346
+ enter(getFunctionConstruction(definition, isLet), definition.location.range, () => {
347
+ walk(definition.body, bindNames(names, resolved.scope));
348
+ getBoundSets(definition.bounds).forEach((set) => walk(set, resolved.scope));
349
+ });
350
+ } else walk(definition.body, bindNames(names, resolved.scope));
309
351
  walking.pop();
310
352
  };
311
353
 
@@ -380,20 +422,18 @@ export const buildCoverage = (
380
422
  case "Lambda":
381
423
  walk(expression.body, bindNames(expression.params, locals));
382
424
  return;
425
+ case "Selection":
426
+ if (range === undefined) walk(expression.expression, locals);
427
+ else enter(expression, range, () => walk(expression.expression, locals));
428
+ return;
383
429
  case "Let": {
384
- const inner = expression.definitions.reduce<Local | undefined>(
385
- (parent, definition) => ({ name: definition.name, definition, scope: undefined, parent }),
386
- locals,
387
- );
388
- for (let local = inner; local !== locals && local; local = local.parent) {
389
- local.scope = inner;
390
- }
430
+ const inner = bindLocalDefinitions(expression.definitions, locals);
391
431
  expression.definitions.forEach((definition) => {
392
432
  if (definition.kind === "Operator") letBodies.set(definition.body, expression.body);
393
433
  });
394
- getHashtableOrder(expression.definitions).forEach((definition) =>
395
- walkDefinition({ definition, scope: inner }),
396
- );
434
+ getHashtableOrder(expression.definitions).forEach((definition) => {
435
+ if (definition.name !== SELECTION_NAME) walkDefinition({ definition, scope: inner });
436
+ });
397
437
  walk(expression.body, inner);
398
438
  return;
399
439
  }
@@ -551,9 +591,18 @@ export const buildCoverage = (
551
591
  }
552
592
  };
553
593
 
594
+ const getScopeLocals = (scope: Scope | undefined) => {
595
+ const scoped: Definition[] = [];
596
+ for (let node = scope; node; node = node.parent) {
597
+ const definition = letDefinitions.get(node);
598
+ if (definition) scoped.unshift(definition);
599
+ }
600
+ return bindLocalDefinitions(scoped, undefined);
601
+ };
602
+
554
603
  coverage.relations.forEach((relation) => {
555
604
  stack.push(relation.node);
556
- walk(relation.expression, undefined);
605
+ walk(relation.expression, getScopeLocals(relation.scope));
557
606
  stack.pop();
558
607
  });
559
608
  };
@@ -602,6 +651,194 @@ export const costCoverage = (coverage: Coverage, value: Value, cost: number) =>
602
651
  if (node !== undefined) coverage.secondary[node] += cost;
603
652
  };
604
653
 
654
+ export const chargeSetOperation = (
655
+ coverage: Coverage,
656
+ operator: string,
657
+ left: Value,
658
+ right: Value,
659
+ result: Value,
660
+ ): Value => {
661
+ const receiver = isReducibleSet(left)
662
+ ? left
663
+ : operator !== "\\" && isReducibleSet(right)
664
+ ? right
665
+ : undefined;
666
+ if (receiver === undefined || typeof result !== "object") return result;
667
+ const other = receiver === left ? right : left;
668
+ if (operator === "\\cup") {
669
+ if (isEmptySet(receiver) || !isReducibleSet(other)) return result;
670
+ const otherNode = coverage.values.get(other);
671
+ if (otherNode !== undefined) coverage.secondary[otherNode] += getCardinality(other) + 1;
672
+ }
673
+ const node = operator === "\\cup" ? undefined : coverage.values.get(receiver);
674
+ if (coverage.values.get(result) === node) return result;
675
+ const isShared = result === left || result === right || coverage.values.has(result);
676
+ const charged = isShared ? { ...result } : result;
677
+ if (node !== undefined) coverage.values.set(charged, node);
678
+ return charged;
679
+ };
680
+
681
+ interface ChargedEnumerator {
682
+ next: () => boolean;
683
+ reset: () => void;
684
+ }
685
+
686
+ const createListEnumerator = (coverage: Coverage, node: number | undefined, size: number) => {
687
+ let position = 0;
688
+ return {
689
+ next: () => {
690
+ if (node !== undefined) coverage.secondary[node]++;
691
+ return position++ < size;
692
+ },
693
+ reset: () => {
694
+ position = 0;
695
+ },
696
+ };
697
+ };
698
+
699
+ const createProductEnumerator = (
700
+ coverage: Coverage,
701
+ node: number,
702
+ sets: Value[],
703
+ ): ChargedEnumerator => {
704
+ if (sets.some((set) => isEmptySet(set))) return { next: () => false, reset: () => undefined };
705
+ const enumerators = sets.map((set) =>
706
+ createEnumerator(coverage, set, getCardinality(set), false),
707
+ );
708
+ const advance = () => {
709
+ for (let index = enumerators.length - 1; index > 0; index--) {
710
+ if (enumerators[index].next()) return true;
711
+ enumerators[index].reset();
712
+ enumerators[index].next();
713
+ }
714
+ return enumerators.length > 0 && enumerators[0].next();
715
+ };
716
+ let isDone = !enumerators.every((enumerator) => enumerator.next());
717
+ return {
718
+ next: () => {
719
+ if (isDone) return false;
720
+ coverage.secondary[node] += Math.max(enumerators.length, 1);
721
+ isDone = !advance();
722
+ return true;
723
+ },
724
+ reset: () => {
725
+ enumerators.forEach((enumerator) => {
726
+ enumerator.reset();
727
+ enumerator.next();
728
+ });
729
+ isDone = false;
730
+ },
731
+ };
732
+ };
733
+
734
+ export const createProductSetEnumerator = (coverage: Coverage, set: Value) => {
735
+ const node = typeof set === "object" ? coverage.values.get(set) : undefined;
736
+ if (node === undefined || typeof set !== "object") return undefined;
737
+ if (set.kind === "RecordSet") return createProductEnumerator(coverage, node, set.sets);
738
+ if (set.kind !== "FunctionSet") return undefined;
739
+ return createProductEnumerator(
740
+ coverage,
741
+ node,
742
+ Array.from({ length: getCardinality(set.domain) }, () => set.range),
743
+ );
744
+ };
745
+
746
+ const createEnumerator = (
747
+ coverage: Coverage,
748
+ set: Value,
749
+ size: number,
750
+ isNormalized: boolean,
751
+ ): ChargedEnumerator => {
752
+ const node = typeof set === "object" ? coverage.values.get(set) : undefined;
753
+ if (
754
+ typeof set === "object" &&
755
+ (set.kind === "Subset" || (!isNormalized && set.kind === "FilteredSet"))
756
+ ) {
757
+ return createListEnumerator(coverage, undefined, size);
758
+ }
759
+ const elements = createProductSetEnumerator(coverage, set);
760
+ if (!elements || node === undefined) return createListEnumerator(coverage, node, size);
761
+ if (!isNormalized) return elements;
762
+ let count = 0;
763
+ while (elements.next()) count++;
764
+ coverage.secondary[node] += count;
765
+ return createListEnumerator(coverage, node, count);
766
+ };
767
+
768
+ export const tagSubset = (coverage: Coverage, set: Value, subset: Value) => {
769
+ const node =
770
+ typeof set === "object" && set.kind === "Subset" ? coverage.values.get(set) : undefined;
771
+ if (node !== undefined && typeof subset === "object") coverage.values.set(subset, node);
772
+ };
773
+
774
+ const RANDOMLY_INDEXED_KINDS = new Set<string>([
775
+ "Set",
776
+ "MixedSet",
777
+ "Interval",
778
+ "FunctionSet",
779
+ "RecordSet",
780
+ "ProductSet",
781
+ ]);
782
+
783
+ // TLC's EnumerableValue#elements(Ordering.RANDOMIZED) draws indices, but a value class without its own k-out-of-n enumerator draws the whole set first, and SubsetValue converts itself to a SetEnumValue.
784
+ export const chargeRandomOrder = (coverage: Coverage, set: Value, size: number, order: Value[]) => {
785
+ if (typeof set !== "object" || RANDOMLY_INDEXED_KINDS.has(set.kind)) return;
786
+ if (set.kind !== "Subset") {
787
+ const enumerator = createEnumerator(coverage, set, size, false);
788
+ for (let position = 0; position <= size; position++) enumerator.next();
789
+ return;
790
+ }
791
+ const node = coverage.values.get(set);
792
+ if (node !== undefined) coverage.secondary[node] += size;
793
+ for (let position = 0; position < order.length; position++) {
794
+ tagSubset(coverage, set, order[position]);
795
+ }
796
+ };
797
+
798
+ export const createChargedEnumerator = (
799
+ coverage: Coverage,
800
+ set: Value,
801
+ list: Value[] | IntervalValue,
802
+ isNormalized: boolean,
803
+ ) => {
804
+ const size = Array.isArray(list) ? list.length : list.high - list.low + 1;
805
+ if (typeof set !== "object" || set.kind !== "Subset" || !Array.isArray(list)) {
806
+ return createEnumerator(coverage, set, size, isNormalized);
807
+ }
808
+ list.forEach((subset) => tagSubset(coverage, set, subset));
809
+ return createListEnumerator(coverage, undefined, size);
810
+ };
811
+
812
+ const chargeBindings = (enumerators: ChargedEnumerator[]) => {
813
+ enumerators.every((enumerator) => enumerator.next());
814
+ return () => {
815
+ for (let index = 0; index < enumerators.length; index++) {
816
+ if (enumerators[index].next() || index === enumerators.length - 1) return;
817
+ enumerators[index].reset();
818
+ enumerators[index].next();
819
+ }
820
+ };
821
+ };
822
+
823
+ export const chargeContexts = (
824
+ coverage: Coverage,
825
+ sets: Value[],
826
+ lists: (Value[] | IntervalValue)[],
827
+ ) =>
828
+ chargeBindings(
829
+ sets.map((set, index) => createChargedEnumerator(coverage, set, lists[index], true)),
830
+ );
831
+
832
+ export const chargeFunctionConstruction = (coverage: Coverage, node: number, sets: Value[]) => {
833
+ const sizes = sets.map((set) => getCardinality(set));
834
+ const advance = chargeBindings(
835
+ sets.map((set, index) => createEnumerator(coverage, set, sizes[index], false)),
836
+ );
837
+ const size = sizes.reduce((product, setSize) => product * setSize, 1);
838
+ for (let index = 0; index < size; index++) advance();
839
+ coverage.secondary[node] += size;
840
+ };
841
+
605
842
  const getLeadingZeros = (value: bigint) => {
606
843
  const high = Number(value >> 32n);
607
844
  return high === 0 ? 32 + Math.clz32(Number(value & 0xffffffffn)) : Math.clz32(high);