tla-ts 0.0.3-dev.4c8c06c → 0.0.3-dev.4fdd845

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 (84) hide show
  1. package/README.md +16 -2
  2. package/dist/cli.cjs +1 -1
  3. package/dist/cli.js +1 -1
  4. package/dist/index.cjs +1 -1
  5. package/dist/index.d.cts +157 -8
  6. package/dist/index.d.ts +157 -8
  7. package/dist/index.js +1 -1
  8. package/dist/parallel-worker.cjs +1 -1
  9. package/dist/parallel-worker.js +2 -2
  10. package/dist/parallel.cjs +1 -1
  11. package/dist/parallel.js +2 -2
  12. package/dist/run-cli.cjs +1351 -19
  13. package/dist/run-cli.js +1351 -19
  14. package/dist/transfer.cjs +86 -16
  15. package/dist/transfer.js +86 -16
  16. package/package.json +5 -1
  17. package/src/ast.ts +142 -6
  18. package/src/bags.ts +4 -7
  19. package/src/builtins.ts +29 -11
  20. package/src/bundled-modules.ts +3 -3
  21. package/src/canonical.ts +4 -3
  22. package/src/check.ts +1539 -235
  23. package/src/cli-options.ts +11 -5
  24. package/src/cli.ts +8 -1
  25. package/src/codegen.ts +77 -37
  26. package/src/config.ts +252 -179
  27. package/src/dependencies.ts +2 -2
  28. package/src/environment.ts +518 -137
  29. package/src/errors.ts +224 -3
  30. package/src/evaluate.ts +796 -246
  31. package/src/exit-codes.ts +22 -43
  32. package/src/index.ts +1 -0
  33. package/src/instances.ts +19 -16
  34. package/src/java-overrides.ts +104 -25
  35. package/src/levels.ts +191 -45
  36. package/src/lexer.ts +32 -4
  37. package/src/live-check.ts +828 -0
  38. package/src/liveness.ts +218 -572
  39. package/src/obligation-expression.ts +2 -2
  40. package/src/obligation-source.ts +2 -0
  41. package/src/parallel-worker.ts +13 -4
  42. package/src/parallel.ts +73 -6
  43. package/src/parser.ts +447 -128
  44. package/src/pcal-ast.ts +770 -0
  45. package/src/pcal-parse.ts +1523 -0
  46. package/src/pcal-tokenize.ts +516 -0
  47. package/src/pcal-translate.ts +1230 -0
  48. package/src/pcal-validate.ts +454 -0
  49. package/src/randomization.ts +24 -7
  50. package/src/resolve.ts +1380 -420
  51. package/src/run-cli.ts +1200 -143
  52. package/src/runtime.ts +19 -1
  53. package/src/sany-builtins.ts +147 -0
  54. package/src/sany-generator.ts +3112 -0
  55. package/src/sany-levels.ts +1208 -0
  56. package/src/sany-lexer.ts +545 -0
  57. package/src/sany-linter.ts +122 -0
  58. package/src/sany-modules.ts +1398 -0
  59. package/src/sany-nodes.ts +463 -0
  60. package/src/sany-parse-error.ts +2161 -0
  61. package/src/sany-report.ts +354 -0
  62. package/src/sany-selectors.ts +738 -0
  63. package/src/sany-source.ts +248 -0
  64. package/src/sany-xml.ts +1017 -0
  65. package/src/spec-description.ts +42 -11
  66. package/src/standard-modules.ts +200 -148
  67. package/src/standard-ranges.ts +116 -0
  68. package/src/state-graph.ts +180 -0
  69. package/src/subexpressions.ts +231 -171
  70. package/src/substitution-levels.ts +38 -17
  71. package/src/successors.ts +219 -107
  72. package/src/symmetry.ts +180 -52
  73. package/src/tableau.ts +54 -25
  74. package/src/tlc-ext.ts +42 -29
  75. package/src/tlc-messages.ts +329 -0
  76. package/src/tlc-module.ts +52 -43
  77. package/src/tlc-order.ts +73 -9
  78. package/src/tlc-random.ts +37 -9
  79. package/src/tlc-replay.ts +655 -0
  80. package/src/tlc-summary.ts +20 -5
  81. package/src/tlc-version.ts +18 -0
  82. package/src/transfer.ts +15 -3
  83. package/src/value-sources.ts +29 -0
  84. package/src/values.ts +708 -180
package/src/check.ts CHANGED
@@ -1,32 +1,52 @@
1
- import type { Assumption, Definition, Expression, SourceLocation } from "./ast";
1
+ import {
2
+ getChildren,
3
+ isLocallyResolved,
4
+ type Assumption,
5
+ type Definition,
6
+ type Expression,
7
+ type SourceLocation,
8
+ } from "./ast";
2
9
  import { parseConfig, type ConfigValue, type ModelConfig } from "./config";
3
10
  import { getReadVariables } from "./dependencies";
4
11
  import { createEnvironment } from "./environment";
5
- import { getErrorExitCode, TlaConfigError, TlaEvaluationError, TlaModuleError } from "./errors";
6
- import { EXIT_STATUS, setExitCode, setNextStatePhase, withLivenessExitCode } from "./exit-codes";
7
12
  import {
13
+ getErrorExitCode,
14
+ isStackOverflow,
15
+ TlaConfigError,
16
+ TlaEvaluationError,
17
+ TlaIllegalStateError,
18
+ TlaIncompleteSuccessorError,
19
+ TlaModuleError,
20
+ TlaStackOverflowError,
21
+ getUnexpectedException,
22
+ UNEXPECTED_EXCEPTION,
23
+ } from "./errors";
24
+ import type { JavaOverride } from "./java-overrides";
25
+ import { EXIT_STATUS, getExitCode, setExitCode, withLivenessExitCode } from "./exit-codes";
26
+ import {
27
+ describeNode,
8
28
  describeRange,
29
+ createTracingEnvironment,
9
30
  evaluate,
31
+ evaluateStartupDefinitions,
10
32
  expectBoolean,
11
33
  formatRange,
12
- getChildren,
13
34
  getDefinition,
14
35
  isConstantLevel,
15
36
  isImpure,
16
- isLocallyResolved,
37
+ type CallStack,
17
38
  type Context,
18
39
  type Environment,
40
+ type FingerprintFailure,
19
41
  type Scope,
20
42
  } from "./evaluate";
21
43
  import {
22
44
  createLivenessChecker,
23
- expandTemporal,
24
- getLevel,
25
45
  type Lasso,
46
+ type LivenessChecker,
26
47
  type LiveSuccessor,
27
- type ScopedExpression,
28
- type TemporalProperty,
29
- } from "./liveness";
48
+ } from "./live-check";
49
+ import { expandTemporal, getLevel, type ScopedExpression, type TemporalProperty } from "./liveness";
30
50
  import { ACTION_LEVEL, createLevelAnalyzer, TEMPORAL_LEVEL } from "./levels";
31
51
  import { prettyPrint } from "./pretty-print";
32
52
  import {
@@ -38,25 +58,49 @@ import {
38
58
  } from "./successors";
39
59
  import {
40
60
  getActionLabel,
61
+ getActionSignature,
62
+ getInitActions,
41
63
  getNextActions,
42
64
  getSpecificationValue,
65
+ toActionValue,
43
66
  type SpecAction,
44
67
  } from "./spec-description";
68
+ import {
69
+ createStateWriter,
70
+ type GraphState,
71
+ type StateDump,
72
+ type StateWriter,
73
+ } from "./state-graph";
45
74
  import { getRepresentative, getSymmetryGroup } from "./symmetry";
46
75
  import { getTlcStringOrder, getTlcVariableOrder } from "./tlc-order";
76
+ import {
77
+ formatNestedMessage,
78
+ getCodedMessage,
79
+ isEvalException,
80
+ MESSAGE_CODE,
81
+ MISSING_INIT_174,
82
+ } from "./tlc-messages";
83
+ import { replayInitialStates, replaySuccessors } from "./tlc-replay";
47
84
  import { createTlcFingerprinter, getTlcFingerprint } from "./tlc-random";
48
85
  import { createCanonicalizer } from "./canonical";
49
86
  import { getPossibleCounts, type CheckerRuntime } from "./runtime";
50
- import { createCounterExample } from "./tlc-ext";
87
+ import { createActionRecord, createCounterExample } from "./tlc-ext";
51
88
  import { getFingerprintDistance, OUT_DEGREE_BUCKETS } from "./tlc-summary";
89
+ import type { TlcVersion } from "./tlc-version";
52
90
  import {
53
91
  combineHash,
92
+ createModelValue,
93
+ formatState,
54
94
  formatValue,
95
+ getHeldValues,
96
+ getFingerprintError,
97
+ markFingerprinted,
55
98
  getValueHash,
56
99
  isFunctionValue,
57
100
  isSameValue,
58
101
  isUpdatedElementOf,
59
102
  setStringOrder,
103
+ setValueVersion,
60
104
  toFiniteFunction,
61
105
  type Value,
62
106
  } from "./values";
@@ -74,8 +118,73 @@ export interface CheckOptions {
74
118
  workers?: number;
75
119
  // TLC's -lncheck: "final" checks liveness only on the complete state graph.
76
120
  livenessCheck?: "default" | "final";
121
+ // TLC's -dump: writes the reachable states, or with `dot` the state graph, through writeFile.
122
+ dump?: StateDump;
123
+ // TLC's -tool, which changes the messages of TLC's errors.
124
+ isTool?: boolean;
125
+ // Whether TLC records a binary trace for its trace exploration spec, for which it loads Integers.
126
+ isTraceRecorded?: boolean;
127
+ // Whether the caller printed SANY's report, its warnings included, before the check.
128
+ isSanyReported?: boolean;
129
+ // False for TLC's -nowarning, which changes how TLC computes the successors of some actions.
130
+ isWarningEnabled?: boolean;
131
+ // The TLC whose output tla-ts reproduces, which changes how TLC labels an action.
132
+ version?: TlcVersion;
133
+ // Reports the points of the search at which TLC prints a message.
134
+ onProgress?: (progress: CheckProgress) => void;
77
135
  }
78
136
 
137
+ export interface InitialStatesProgress {
138
+ kind: "initial-states-progress";
139
+ count: number;
140
+ }
141
+
142
+ // A check that TLC's DoInitFunctor reports as violated before it stops its replay of the initial
143
+ // states.
144
+ export interface InitialStateViolation {
145
+ kind: "initial-state-violation";
146
+ status: "invariant-violation" | "liveness-violation";
147
+ name: string;
148
+ state: Record<string, Value>;
149
+ }
150
+
151
+ // A line the spec prints, or what TLC reports as it replays the initial states.
152
+ export type OutputLine = string | InitialStatesProgress | InitialStateViolation;
153
+
154
+ // The spec is parsed, TLC warns about each invariant that is a true constant formula and each
155
+ // property that is a state formula, finds the branches of the temporal properties, computes the
156
+ // initial states, reporting each time their count reaches a power of two, reports how far the
157
+ // search got 3 seconds after it starts and every minute after, and checks the temporal properties
158
+ // on the state graph so far at those times and on the complete state graph at the end.
159
+ export type CheckProgress =
160
+ | { kind: "parsed" }
161
+ | { kind: "constant-level-invariant"; name: string }
162
+ | { kind: "state-level-property"; name: string }
163
+ | { kind: "liveness-initializing"; isSymmetric: boolean; isConstrained: boolean }
164
+ | { kind: "liveness-prepared"; branches: number }
165
+ | { kind: "initial-states-started" }
166
+ | InitialStatesProgress
167
+ | { kind: "initial-states-computed"; initialStates: InitialStates }
168
+ | { kind: "progress"; statistics: SearchStatistics }
169
+ | {
170
+ kind: "liveness-started";
171
+ branches: number;
172
+ // Whether TLC checks the complete state graph, and how many states of it each branch has.
173
+ isComplete: boolean;
174
+ states: number;
175
+ statistics: SearchStatistics;
176
+ }
177
+ | { kind: "liveness-finished" }
178
+ // A warning TLC prints as it evaluates the spec, with its message code.
179
+ | { kind: "warning"; code: number; text: string }
180
+ // A method of the class named after a module, which TLC reports as it loads the class.
181
+ | ({ kind: "java-override" } & JavaOverride);
182
+
183
+ export interface SearchStatistics extends Pick<
184
+ CheckResult,
185
+ "generatedStates" | "distinctStates" | "queuedStates" | "depth"
186
+ > {}
187
+
79
188
  export type CheckStatus =
80
189
  | "success"
81
190
  | "assumption-violation"
@@ -91,30 +200,74 @@ export interface TraceStep {
91
200
  // TLC's name, parameters and location for the action that took this step.
92
201
  label: string | undefined;
93
202
  state: Record<string, Value>;
203
+ // What the spec prints, before TLC prints this step, as TLC evaluates it again to rebuild the
204
+ // trace. The first step has what TLC prints before the trace.
205
+ output?: OutputLine[];
94
206
  }
95
207
 
96
208
  export interface Violation {
97
209
  name: string;
210
+ // Every temporal property that a liveness counterexample violates, in the configuration's order.
211
+ properties?: string[];
98
212
  trace: TraceStep[];
213
+ // What the spec prints after TLC prints the states of the trace, as TLC finds the step back into
214
+ // the cycle of a lasso or rebuilds the trace once more.
215
+ traceOutput?: OutputLine[];
99
216
  loopStart: number | undefined;
100
217
  loopLabel?: string;
101
218
  message?: string;
102
219
  counts?: string;
103
220
  unwitnessed?: Postcondition;
221
+ // A POSTCONDITION that is false or fails after the counterexample, which TLC checks as it
222
+ // prints one.
223
+ postcondition?: Postcondition;
224
+ // What TLC warns about after a counterexample, with its code.
225
+ warning?: { code: number; text: string };
104
226
  }
105
227
 
106
228
  interface Postcondition {
107
229
  name: string;
230
+ // TLC's message code.
231
+ code: number;
108
232
  message: string;
109
233
  counts?: string;
110
234
  }
111
235
 
112
236
  // An evaluation that failed during the search, with the behavior up to the state TLC was working on.
113
237
  export interface EvaluationFailure {
238
+ // TLC's code for the message, and its text with and without -tool.
239
+ code: number;
114
240
  message: string;
241
+ toolMessage: string;
115
242
  trace: TraceStep[];
243
+ traceOutput?: OutputLine[];
116
244
  initialState: Record<string, Value> | undefined;
117
245
  exitCode: number;
246
+ // The expressions TLC was evaluating when the failure occurred, outermost first, when TLC finds
247
+ // them by replaying the failure.
248
+ callStack: Expression[] | undefined;
249
+ // Whether TLC prints the call stack before the error, as it does for a failed liveness check.
250
+ isCallStackFirst?: boolean;
251
+ // The FingerprintException the replay raises, which TLC reports in place of the call stack.
252
+ fingerprint?: FingerprintFailure;
253
+ // How TLC reports failing again as it prints the trace, since it can't fingerprint the state the
254
+ // failure occurred in.
255
+ traceFailure?: FailureMessage;
256
+ // A POSTCONDITION that is false or fails after the trace, which TLC checks as it prints one.
257
+ postcondition?: Postcondition;
258
+ // Whether TLC stops before it prints the statistics, as it does for an illegal initial state.
259
+ isWithoutStatistics?: boolean;
260
+ }
261
+
262
+ // Where TLC's replay of a failure fails.
263
+ interface ReplayFailure {
264
+ callStack: Expression[];
265
+ fingerprint: FingerprintFailure | undefined;
266
+ }
267
+
268
+ export interface InitialStates {
269
+ generated: number;
270
+ distinct: number;
118
271
  }
119
272
 
120
273
  export interface CheckResult {
@@ -125,14 +278,55 @@ export interface CheckResult {
125
278
  distinctStates: number;
126
279
  queuedStates: number;
127
280
  depth: number;
281
+ // How many initial states TLC generated and how many of them were distinct, once it computed
282
+ // them all without a violation or an error.
283
+ initialStates: InitialStates | undefined;
128
284
  // How many states that TLC counts as expanded found each number of new states, when TLC prints
129
285
  // the outdegree of the state graph.
130
286
  outDegrees: number[] | undefined;
131
287
  // The smallest distance between the fingerprints of two distinct states, when TLC estimates a
132
288
  // collision from the actual fingerprints.
133
289
  fingerprintDistance: bigint | undefined;
290
+ // A temporal property TLC finds violated as it adds a deadlocked state to the behavior graph,
291
+ // which it reports after the deadlock.
292
+ additionalViolation?: Violation;
293
+ // Where TLC's worker fails to add the state to the behavior graph after it reports a violation.
294
+ liveCallStack?: Expression[];
295
+ // How many states that TLC counts as expanded found each number of new states, when its workers
296
+ // stop on a violation without an error code, which TLC 1.7.4 reports as a successful search.
297
+ violationOutDegrees?: number[];
298
+ }
299
+
300
+ interface Behavior {
301
+ trace: TraceStep[];
302
+ traceOutput?: OutputLine[];
303
+ }
304
+
305
+ interface TraceOptions {
306
+ loopStart?: number;
307
+ known?: number;
134
308
  }
135
309
 
310
+ interface FailureOptions {
311
+ initialState?: Value[];
312
+ isInitial?: boolean;
313
+ outDegrees?: number[];
314
+ callStack?: Expression[];
315
+ fingerprint?: FingerprintFailure;
316
+ isNextState?: boolean;
317
+ isCallStackFirst?: boolean;
318
+ traceFailure?: FailureMessage;
319
+ // Whether the call stack is of adding the state to the behavior graph, which TLC prints instead
320
+ // of replaying the error.
321
+ isLiveCallStack?: boolean;
322
+ }
323
+
324
+ // TLC prints what the spec prints as it replays a failure after the trace.
325
+ const appendTraceOutput = <Traced extends Behavior>(behavior: Traced, lines: OutputLine[]) => ({
326
+ ...behavior,
327
+ traceOutput: [...(behavior.traceOutput ?? []), ...lines],
328
+ });
329
+
136
330
  interface NamedExpression {
137
331
  name: string;
138
332
  expression: Expression;
@@ -142,6 +336,8 @@ interface NamedExpression {
142
336
  interface StateCheck extends NamedExpression {
143
337
  variables: number[] | undefined;
144
338
  membership: Membership | undefined;
339
+ // The whole predicate that TLC evaluates for the check, of which the expression is a conjunct.
340
+ predicate: Expression;
145
341
  }
146
342
 
147
343
  // A conjunct `x \in S` whose S reads no variables.
@@ -210,14 +406,6 @@ const getConfigOperator = (kind: string, name: string, environment: Environment)
210
406
  return definition;
211
407
  };
212
408
 
213
- const getConfigDefinition = (kind: string, name: string, environment: Environment) => {
214
- const definition = getConfigOperator(kind, name, environment);
215
- if (isConstantLevel(definition, environment)) {
216
- throw new TlaConfigError(`The ${kind} ${name} cannot be a constant.`);
217
- }
218
- return definition;
219
- };
220
-
221
409
  // TLC evaluates every constant definition before it reads the configuration. It keeps a literal
222
410
  // number or string, and a definition that fails to evaluate, as an operator.
223
411
  const getConstantValue = (name: string, definition: Definition, environment: Environment) => {
@@ -226,20 +414,77 @@ const getConstantValue = (name: string, definition: Definition, environment: Env
226
414
  try {
227
415
  return evaluate(createIdentifier(name), getContext(environment, undefined, undefined));
228
416
  } catch (error) {
229
- if (error instanceof TlaEvaluationError) return undefined;
417
+ // TLC swallows whatever the definition throws, a stack overflow included.
418
+ if (error instanceof TlaEvaluationError || isStackOverflow(error)) return undefined;
230
419
  throw error;
231
420
  }
232
421
  };
233
422
 
234
- const getConfigPredicate = (kind: string, name: string, environment: Environment) => {
423
+ // TLC takes for an operator only a definition it hasn't replaced with its value.
424
+ const getConfigDefinition = (kind: string, name: string, environment: Environment) => {
235
425
  const definition = getConfigOperator(kind, name, environment);
236
- const value = getConstantValue(name, definition, environment);
426
+ if (getConstantValue(name, definition, environment) !== undefined) {
427
+ throw new TlaConfigError(`The ${kind} ${name} cannot be a constant.`);
428
+ }
429
+ return definition;
430
+ };
431
+
432
+ // TLC also takes a constant that the configuration assigns a value, which must be TRUE.
433
+ const getConfigPredicate = (kind: string, name: string, environment: Environment) => {
434
+ const definition = environment.constants.has(name)
435
+ ? undefined
436
+ : getConfigOperator(kind, name, environment);
437
+ const value = definition
438
+ ? getConstantValue(name, definition, environment)
439
+ : environment.constants.get(name);
237
440
  if (value !== undefined && value !== true) {
238
441
  throw new TlaConfigError(`The ${kind} of ${name} is equal to ${formatValue(value)}`);
239
442
  }
240
443
  return value === undefined ? definition : undefined;
241
444
  };
242
445
 
446
+ // TLC reports how many initial states it has computed each time the count is a power of two.
447
+ export const reportInitialStatesProgress = (
448
+ count: number,
449
+ onProgress: ((progress: InitialStatesProgress) => void) | undefined,
450
+ ) => {
451
+ if (count > 1 && (count & (count - 1)) === 0) {
452
+ onProgress?.({ kind: "initial-states-progress", count });
453
+ }
454
+ };
455
+
456
+ // What TLC does once SANY is done: it computes the constant definitions, then warns about each
457
+ // invariant that is a true constant formula, which it doesn't check. TLC prints each distinct
458
+ // warning once.
459
+ export const reportStartup = (
460
+ specification: {
461
+ environment: Environment;
462
+ startupDefinitions: Definition[];
463
+ javaOverrides: JavaOverride[];
464
+ },
465
+ config: ModelConfig,
466
+ onProgress: CheckOptions["onProgress"],
467
+ ) => {
468
+ const environment = specification.environment;
469
+ const warned = new Set<string>();
470
+ environment.runtime.warn = (code, text) => {
471
+ if (warned.has(text)) return;
472
+ warned.add(text);
473
+ onProgress?.({ kind: "warning", code, text });
474
+ };
475
+ onProgress?.({ kind: "parsed" });
476
+ // TLC loads the classes of the modules before it computes the constant definitions.
477
+ specification.javaOverrides.forEach((override) =>
478
+ onProgress?.({ kind: "java-override", ...override }),
479
+ );
480
+ evaluateStartupDefinitions(specification.startupDefinitions, environment);
481
+ config.invariants.forEach((name) => {
482
+ if (!getConfigPredicate("invariant", name, environment)) {
483
+ onProgress?.({ kind: "constant-level-invariant", name });
484
+ }
485
+ });
486
+ };
487
+
243
488
  const getInvariants = (names: string[], environment: Environment) => {
244
489
  const analyzer = createLevelAnalyzer({
245
490
  constants: new Set(environment.constants.keys()),
@@ -255,8 +500,11 @@ const getInvariants = (names: string[], environment: Environment) => {
255
500
  levels.params.size === 0
256
501
  ? ""
257
502
  : "\nNote that a bug can cause TLC to incorrectly report this error.\nIf you believe your TLA+ or PlusCal specification to be correct,\nplease check if this bug described in LevelNode.java starting at line 590ff affects you.";
258
- throw new TlaConfigError(
259
- `The invariant ${name} is not a state predicate (one with no primes or temporal operators).${note}`,
503
+ throw setExitCode(
504
+ new TlaConfigError(
505
+ `The invariant ${name} is not a state predicate (one with no primes or temporal operators).${note}`,
506
+ ),
507
+ EXIT_STATUS.safetyEvaluationFailure,
260
508
  );
261
509
  }
262
510
  return [{ name, expression: createIdentifier(name), scope: undefined }];
@@ -309,14 +557,8 @@ const getSpecification = (config: ModelConfig, environment: Environment): Specif
309
557
  if (config.specification === undefined) {
310
558
  const getOperator = (name: string | undefined, description: string) => {
311
559
  if (name === undefined) return undefined;
312
- const body = getConfigOperator(description, name, environment).body;
313
- const identifier = createIdentifier(name);
314
- // TLC evaluates a literal body later and reports that it is not a boolean.
315
- const isLiteral = body.kind === "Number" || body.kind === "String";
316
- if (!isLiteral && getLevel(identifier, undefined, environment) === 0) {
317
- throw new TlaConfigError(`The ${description} ${name} cannot be a constant.`);
318
- }
319
- return identifier;
560
+ getConfigDefinition(description, name, environment);
561
+ return createIdentifier(name);
320
562
  };
321
563
  return {
322
564
  init: getOperator(config.init, "initial predicate"),
@@ -325,6 +567,11 @@ const getSpecification = (config: ModelConfig, environment: Environment): Specif
325
567
  temporals: [],
326
568
  };
327
569
  }
570
+ if (config.init !== undefined || config.next !== undefined) {
571
+ throw new TlaConfigError(
572
+ "The configuration file cannot specify both INIT/NEXT and SPECIFICATION fields.",
573
+ );
574
+ }
328
575
  const initConjuncts: ScopedExpression[] = [];
329
576
  const nextActions: ScopedExpression[] = [];
330
577
  const temporals: ScopedExpression[] = [];
@@ -354,8 +601,12 @@ const getSpecification = (config: ModelConfig, environment: Environment): Specif
354
601
  conjunct.kind === "Always" &&
355
602
  getLevel(conjunct.expression, item.scope, environment) < ACTION_LEVEL
356
603
  ) {
357
- throw new TlaConfigError(
358
- `TLC cannot handle []P in the specification ${config.specification} when P is a state predicate`,
604
+ // TLC accepts the spec and fails when it builds the tableau of the temporal formulas.
605
+ throw setExitCode(
606
+ new TlaEvaluationError(
607
+ `TLC cannot handle the temporal formula ${describeRange(conjunct.expression)}`,
608
+ ),
609
+ EXIT_STATUS.error,
359
610
  );
360
611
  }
361
612
  const level = getLevel(conjunct, item.scope, environment);
@@ -415,7 +666,11 @@ const getSpecification = (config: ModelConfig, environment: Environment): Specif
415
666
  };
416
667
  };
417
668
 
418
- const getProperties = (config: ModelConfig, environment: Environment): Properties => {
669
+ const getProperties = (
670
+ config: ModelConfig,
671
+ environment: Environment,
672
+ onProgress: CheckOptions["onProgress"],
673
+ ): Properties => {
419
674
  const properties: Properties = {
420
675
  initialPredicates: [],
421
676
  invariants: [],
@@ -425,12 +680,21 @@ const getProperties = (config: ModelConfig, environment: Environment): Propertie
425
680
  config.properties.forEach((name) => {
426
681
  const definition = getConfigPredicate("property", name, environment);
427
682
  if (!definition) return;
428
- expandTemporal(definition.body, undefined, environment, true).forEach((item) => {
683
+ // TLC checks a property that is a state formula only on the initial states, so it warns about
684
+ // one as it processes the property, before the constraints.
685
+ if (getLevel(definition.body, undefined, environment) === 1) {
686
+ onProgress?.({ kind: "state-level-property", name });
687
+ }
688
+ // TLC 1.7.4 expands a property as it does a specification, so it doesn't unroll one that
689
+ // quantifies over a constant set.
690
+ const isProperty = environment.runtime.version !== "1.7.4";
691
+ expandTemporal(definition.body, undefined, environment, isProperty).forEach((item) => {
429
692
  const conjunct = item.expression;
430
693
  if (isConstantTrue(item, environment, "property")) return;
694
+ const partName = item.name ?? name;
431
695
  if (conjunct.kind === "Always" && conjunct.expression.kind === "BoxAction") {
432
696
  properties.actionProperties.push({
433
- name,
697
+ name: partName,
434
698
  box: conjunct.expression,
435
699
  action: conjunct.expression.action,
436
700
  subscript: conjunct.expression.subscript,
@@ -442,12 +706,28 @@ const getProperties = (config: ModelConfig, environment: Environment): Propertie
442
706
  conjunct.kind === "Always" &&
443
707
  getLevel(conjunct.expression, item.scope, environment) <= 1
444
708
  ) {
445
- properties.invariants.push({ name, expression: conjunct.expression, scope: item.scope });
709
+ // TLC names the invariant by the operator the property asserts always holds, when it
710
+ // applies the operator to no arguments. The name of an operator another module defines
711
+ // resolves to its key, so the name comes from its definition.
712
+ const body = conjunct.expression;
713
+ const operator =
714
+ body.kind === "Identifier" && !isLocallyResolved(body)
715
+ ? getDefinition(body.name, environment)
716
+ : undefined;
717
+ properties.invariants.push({
718
+ name: operator?.name ?? (body.kind === "Identifier" ? body.name : partName),
719
+ expression: body,
720
+ scope: item.scope,
721
+ });
446
722
  return;
447
723
  }
448
724
  const level = getLevel(conjunct, item.scope, environment);
449
725
  if (level < ACTION_LEVEL) {
450
- properties.initialPredicates.push({ name, expression: conjunct, scope: item.scope });
726
+ properties.initialPredicates.push({
727
+ name: partName,
728
+ expression: conjunct,
729
+ scope: item.scope,
730
+ });
451
731
  return;
452
732
  }
453
733
  if (level === ACTION_LEVEL) {
@@ -504,16 +784,30 @@ const getMembership = (
504
784
  : undefined;
505
785
  };
506
786
 
787
+ // TLC evaluates the body of an invariant that the configuration names.
788
+ const getPredicate = (expression: Expression, environment: Environment) => {
789
+ if (expression.kind !== "Identifier" || environment.constants.has(expression.name)) {
790
+ return expression;
791
+ }
792
+ const definition = getDefinition(expression.name, environment);
793
+ return definition?.kind === "Operator" && definition.params.length === 0
794
+ ? definition.body
795
+ : expression;
796
+ };
797
+
507
798
  const getStateChecks = (named: NamedExpression[], environment: Environment): StateCheck[] =>
508
799
  named.flatMap((item) =>
509
800
  getConjuncts(item.expression, environment).map((expression) => {
510
- const variables = getReadVariables(expression, environment);
801
+ // A LET or an argument in the scope can read variables the expression doesn't name.
802
+ const variables =
803
+ item.scope === undefined ? getReadVariables(expression, environment) : undefined;
511
804
  return {
512
805
  name: item.name,
513
806
  expression,
514
807
  scope: item.scope,
515
808
  variables,
516
809
  membership: getMembership(expression, variables, environment),
810
+ predicate: getPredicate(item.expression, environment),
517
811
  };
518
812
  }),
519
813
  );
@@ -562,7 +856,25 @@ interface Search {
562
856
  getStoredFingerprints: (states: Value[][], fingerprintStates: Value[][]) => BigInt64Array;
563
857
  getTlcOrder: () => number[];
564
858
  isSymmetric: boolean;
859
+ // TLC drops a constraint that is a true constant formula.
860
+ isConstrained: boolean;
565
861
  findViolatedInvariant: (state: Value[], parent?: Value[]) => StateCheck | undefined;
862
+ // The checks of a state that TLC evaluates when it replays the computation of the initial states
863
+ // or of the successors of a state, with an environment that records the call stack. The first
864
+ // returns the check that stops the replay, and the second false where TLC stops it.
865
+ // TLC fingerprints a replayed state that satisfies the constraints before it checks the rest.
866
+ checkReplayedInitialState: (
867
+ state: Value[],
868
+ tracing: Environment,
869
+ addFingerprint: () => void,
870
+ ) => Pick<InitialStateViolation, "status" | "name"> | undefined;
871
+ // Adding the fingerprint of a successor tells whether TLC had not seen it yet.
872
+ checkReplayedSuccessor: (
873
+ state: Value[],
874
+ next: Value[],
875
+ tracing: Environment,
876
+ addFingerprint: () => boolean,
877
+ ) => boolean;
566
878
  satisfiesConstraints: (state: Value[], parent?: Value[]) => boolean;
567
879
  findFailedInitialPredicate: (state: Value[]) => NamedExpression | undefined;
568
880
  findViolatedActionProperty: (state: Value[], next: Value[]) => ActionProperty | undefined;
@@ -570,7 +882,8 @@ interface Search {
570
882
  trackStatePossible: (state: Value[]) => void;
571
883
  trackActionPossible: (state: Value[], next: Value[]) => void;
572
884
  findUnwitnessedPossible: () => Postcondition | undefined;
573
- findPostconditionViolation: () => Postcondition | undefined;
885
+ // After a counterexample, TLC skips the postconditions when one of them is constant.
886
+ findPostconditionViolation: (isAfterViolation?: boolean) => Postcondition | undefined;
574
887
  }
575
888
 
576
889
  const getContext = (
@@ -596,21 +909,23 @@ const holdsLikeTlc = (
596
909
  return value;
597
910
  };
598
911
 
599
- // SANY prints a number by its digits and any other expression by its location.
600
912
  const getExpectedBoolean = (expression: Expression, environment: Environment) => {
601
913
  const definition =
602
914
  expression.kind === "Identifier" ? getDefinition(expression.name, environment) : undefined;
603
915
  const body = definition?.kind === "Operator" ? definition.body : expression;
604
916
  const range = definition?.kind === "Operator" ? definition.bodyRange : undefined;
605
- const location =
606
- body.kind === "Number"
607
- ? (body.text ?? String(body.value))
608
- : range
609
- ? formatRange(range)
610
- : describeRange(body);
917
+ const location = range && body.kind !== "Number" ? formatRange(range) : describeNode(body);
611
918
  return `TLC expected a boolean value, but did not find one. ${location}`;
612
919
  };
613
920
 
921
+ // TLC evaluates the whole predicate of a check, which fails at a conjunct that isn't a boolean as
922
+ // the conjunction does.
923
+ const holdsAsConjunct = (check: StateCheck, context: Context) =>
924
+ holdsLikeTlc(check.expression, context, (expression, environment) => {
925
+ holdsLikeTlc(check.predicate, context);
926
+ return getExpectedBoolean(expression, environment);
927
+ });
928
+
614
929
  const ignorePossible = () => {};
615
930
 
616
931
  const trackPossible = (items: NamedExpression[], runtime: CheckerRuntime, context: Context) =>
@@ -652,11 +967,16 @@ export const createSearch = (
652
967
  config: ModelConfig,
653
968
  environment: Environment,
654
969
  getVariableOrder: () => string[],
970
+ onProgress?: CheckOptions["onProgress"],
655
971
  ): Search | undefined => {
656
972
  const configInvariants = getInvariants(config.invariants, environment);
657
973
  const spec = getSpecification(config, environment);
658
- const properties = getProperties(config, environment);
974
+ const properties = getProperties(config, environment, onProgress);
659
975
  const invariants = getStateChecks([...configInvariants, ...properties.invariants], environment);
976
+ // The invariants TLC evaluates, each of which may have several conjuncts among the checks.
977
+ const invariantPredicates = [
978
+ ...new Map(invariants.map((invariant) => [invariant.predicate, invariant])).values(),
979
+ ];
660
980
  const isCheckingBehaviors =
661
981
  invariants.length > 0 ||
662
982
  properties.actionProperties.length > 0 ||
@@ -667,7 +987,11 @@ export const createSearch = (
667
987
  properties.initialPredicates.length > 0 ||
668
988
  environment.variables.length > 0)
669
989
  ) {
670
- throw new TlaConfigError("The configuration file did not specify the initial state predicate.");
990
+ throw new TlaConfigError(
991
+ environment.runtime.version === "1.7.4"
992
+ ? MISSING_INIT_174
993
+ : "The configuration file did not specify the initial state predicate.",
994
+ );
671
995
  }
672
996
  if (spec.next === undefined && isCheckingBehaviors) {
673
997
  throw new TlaConfigError("The configuration file did not specify the next state predicate.");
@@ -686,7 +1010,9 @@ export const createSearch = (
686
1010
  const possible = getPossiblePredicates(config.possible, environment);
687
1011
  if (environment.variables.length === 0) return undefined;
688
1012
  const symmetryGroup =
689
- config.symmetry === undefined ? [] : getSymmetryGroup(config.symmetry, environment);
1013
+ config.symmetry === undefined
1014
+ ? undefined
1015
+ : getSymmetryGroup(config.symmetry, environment, config.substitutions);
690
1016
  if (config.view !== undefined) getConfigOperator("view function", config.view, environment);
691
1017
  const view =
692
1018
  config.view === undefined
@@ -718,14 +1044,12 @@ export const createSearch = (
718
1044
  .sort((left, right) => getTlcPosition(left) - getTlcPosition(right));
719
1045
  return tlcOrder.indices;
720
1046
  };
721
- // A representative in TLC's variable order is the one whose fingerprint TLC reports.
722
- const order = symmetryGroup.length > 0 ? getTlcOrder() : undefined;
723
1047
  const getViewValue = (expression: Expression, state: Value[]) =>
724
1048
  evaluate(expression, getContext(environment, state, undefined));
725
1049
  const getTlcStateFingerprint = (state: Value[]) => {
726
1050
  const indices = getTlcOrder();
727
1051
  const representative =
728
- symmetryGroup.length === 0 ? state : getRepresentative(state, symmetryGroup, indices);
1052
+ symmetryGroup === undefined ? state : getRepresentative(state, symmetryGroup, indices);
729
1053
  return getTlcFingerprint(
730
1054
  view === undefined
731
1055
  ? indices.map((index) => representative[index])
@@ -741,6 +1065,7 @@ export const createSearch = (
741
1065
  const location = range ? ` at ${formatRange(range)}` : "";
742
1066
  return {
743
1067
  name: unwitnessed.name,
1068
+ code: MESSAGE_CODE.possibleUnwitnessed,
744
1069
  message: `The _POSSIBLE predicate ${unwitnessed.name}${location} was never witnessed.\nOthers may be unwitnessed too; only witnessed predicates appear with a\nnon-zero count in the record printed above.\nSee https://explain.tlapl.us/possible-conditions for additional details.`,
745
1070
  counts: prettyPrint(formatValue(getPossibleCounts(runtime), true)),
746
1071
  };
@@ -748,22 +1073,28 @@ export const createSearch = (
748
1073
  return {
749
1074
  properties,
750
1075
  spec,
751
- isSymmetric: symmetryGroup.length > 0,
1076
+ isSymmetric: symmetryGroup !== undefined,
1077
+ isConstrained: constraints.length > 0 || actionConstraints.length > 0,
752
1078
  getTlcOrder,
753
1079
  getStoredFingerprints: (states, fingerprintStates) => {
754
1080
  if (view !== undefined || isFingerprintedLikeTlc) {
755
1081
  return BigInt64Array.from(states, getTlcStateFingerprint);
756
1082
  }
757
- const indices = getTlcOrder();
758
- const getFingerprint = createTlcFingerprinter();
759
- return BigInt64Array.from(fingerprintStates, (state) =>
760
- getFingerprint(indices.map((index) => state[index])),
1083
+ const fingerprints = new BigInt64Array(fingerprintStates.length);
1084
+ const fingerprint = createTlcFingerprinter(
1085
+ getTlcOrder(),
1086
+ new Int32Array(fingerprints.buffer),
761
1087
  );
1088
+ fingerprintStates.forEach(fingerprint);
1089
+ return fingerprints;
762
1090
  },
763
1091
  getFingerprintState: (state) => {
764
1092
  if (isFingerprintedLikeTlc) return [String(getTlcStateFingerprint(state))];
1093
+ // A representative in TLC's variable order is the one whose fingerprint TLC reports.
765
1094
  const representative =
766
- symmetryGroup.length === 0 ? state : getRepresentative(state, symmetryGroup, order);
1095
+ symmetryGroup === undefined
1096
+ ? state
1097
+ : getRepresentative(state, symmetryGroup, getTlcOrder());
767
1098
  return view === undefined ? representative : [getViewValue(view.expression, representative)];
768
1099
  },
769
1100
  findViolatedInvariant: (state, parent) =>
@@ -779,21 +1110,63 @@ export const createSearch = (
779
1110
  parent[membership.variable],
780
1111
  evaluate(membership.set, context),
781
1112
  )
782
- : !holdsLikeTlc(invariant.expression, context);
1113
+ : !holdsAsConjunct(invariant, context);
783
1114
  } catch (error) {
784
1115
  // TLC reports a failure only on a state after the initial states as an invariant failure.
785
1116
  if (!parent) throw error;
786
1117
  throw withHeadline(
787
1118
  setExitCode(error, EXIT_STATUS.safetyEvaluationFailure),
1119
+ MESSAGE_CODE.invariantEvaluationFailed,
788
1120
  `Evaluating invariant ${invariant.name} failed.`,
789
1121
  );
790
1122
  }
791
1123
  }),
1124
+ checkReplayedInitialState: (state, tracing, addFingerprint) => {
1125
+ const holdsIn = (expression: Expression, scope: Scope | undefined) =>
1126
+ holdsLikeTlc(expression, getContext(tracing, state, undefined, scope));
1127
+ if (constraints.every((constraint) => holdsIn(constraint.predicate, constraint.scope))) {
1128
+ addFingerprint();
1129
+ }
1130
+ const invariant = invariantPredicates.find((check) => !holdsIn(check.predicate, check.scope));
1131
+ if (invariant) return { status: "invariant-violation", name: invariant.name };
1132
+ const predicate = properties.initialPredicates.find(
1133
+ (check) => !holdsIn(check.expression, check.scope),
1134
+ );
1135
+ return predicate && { status: "liveness-violation", name: predicate.name };
1136
+ },
1137
+ checkReplayedSuccessor: (state, next, tracing, addFingerprint) => {
1138
+ // TLC evaluates the action constraints only on a state that satisfies the constraints.
1139
+ const isInModel =
1140
+ constraints.every((constraint) =>
1141
+ holdsLikeTlc(
1142
+ constraint.predicate,
1143
+ getContext(tracing, next, undefined, constraint.scope),
1144
+ ),
1145
+ ) &&
1146
+ actionConstraints.every((constraint) =>
1147
+ holdsLikeTlc(constraint.expression, getContext(tracing, state, next, constraint.scope)),
1148
+ );
1149
+ // ModelChecker.doNext checks the invariants of a successor it has not seen, which includes
1150
+ // one outside the model.
1151
+ const isUnseen = isInModel ? addFingerprint() : true;
1152
+ return (
1153
+ (!isUnseen ||
1154
+ invariantPredicates.every((invariant) =>
1155
+ holdsLikeTlc(
1156
+ invariant.predicate,
1157
+ getContext(tracing, next, undefined, invariant.scope),
1158
+ ),
1159
+ )) &&
1160
+ actionProperties.every((property) =>
1161
+ holdsLikeTlc(property.box, getContext(tracing, state, next, property.scope)),
1162
+ )
1163
+ );
1164
+ },
792
1165
  satisfiesConstraints: (state, parent) =>
793
1166
  constraints.every(
794
1167
  (constraint) =>
795
1168
  isUnchangedFor(constraint, state, parent) ||
796
- holdsLikeTlc(constraint.expression, getContext(environment, state, undefined)),
1169
+ holdsAsConjunct(constraint, getContext(environment, state, undefined)),
797
1170
  ),
798
1171
  findFailedInitialPredicate: (state) =>
799
1172
  properties.initialPredicates.find(
@@ -820,7 +1193,11 @@ export const createSearch = (
820
1193
  )
821
1194
  );
822
1195
  } catch (error) {
823
- throw withHeadline(error, `Evaluating action property ${property.name} failed.`);
1196
+ throw withHeadline(
1197
+ withNextStateExitCode(error),
1198
+ MESSAGE_CODE.actionPropertyEvaluationFailed,
1199
+ `Evaluating action property ${property.name} failed.`,
1200
+ );
824
1201
  }
825
1202
  }),
826
1203
  satisfiesActionConstraints: (state, next) =>
@@ -828,8 +1205,7 @@ export const createSearch = (
828
1205
  holdsLikeTlc(
829
1206
  constraint.expression,
830
1207
  getContext(environment, state, next),
831
- (expression) =>
832
- `TLC threw an unexpected exception.\nThis was probably caused by an error in the spec or model.\nSee the User Output or TLC Console for clues to what happened.\nThe exception was a java.lang.RuntimeException\n: ${getExpectedBoolean(expression, environment)}`,
1208
+ (expression) => `${UNEXPECTED_EXCEPTION}${getExpectedBoolean(expression, environment)}`,
833
1209
  ),
834
1210
  ),
835
1211
  trackStatePossible:
@@ -843,45 +1219,224 @@ export const createSearch = (
843
1219
  : (state, next) =>
844
1220
  trackPossible(actionPossible, runtime, getContext(environment, state, next)),
845
1221
  findUnwitnessedPossible,
846
- findPostconditionViolation: () => {
1222
+ findPostconditionViolation: (isAfterViolation = false) => {
1223
+ // TLC replaces a definition it computes when it starts by its value, and then rejects it as
1224
+ // a postcondition before it checks any of them.
1225
+ const constant = config.postconditions.find((name) => {
1226
+ const definition = getDefinition(name, environment);
1227
+ return definition !== undefined && environment.definitionValues.has(definition);
1228
+ });
1229
+ if (constant !== undefined) {
1230
+ if (isAfterViolation) return undefined;
1231
+ throw setExitCode(
1232
+ new TlaEvaluationError(
1233
+ `${UNEXPECTED_EXCEPTION}The post condition ${constant} cannot be a constant.`,
1234
+ ),
1235
+ EXIT_STATUS.error,
1236
+ );
1237
+ }
847
1238
  const unwitnessed = findUnwitnessedPossible();
848
1239
  if (unwitnessed) return unwitnessed;
849
1240
  for (const name of config.postconditions) {
850
1241
  const failure = getConstantFailure(createIdentifier(name), environment, "a postcondition");
851
- if (failure) {
852
- return { name, message: failure.message ?? `Postcondition ${name} is false.` };
853
- }
1242
+ if (!failure) continue;
1243
+ const range = getBodyRange(name, environment);
1244
+ const location = range ? ` at ${formatRange(range)}` : "";
1245
+ return failure.message === undefined
1246
+ ? {
1247
+ name,
1248
+ code: MESSAGE_CODE.postconditionFalse,
1249
+ message: `Postcondition ${name}${location} is false.`,
1250
+ }
1251
+ : {
1252
+ name,
1253
+ code: MESSAGE_CODE.postconditionFailed,
1254
+ message: `Evaluating postcondition ${name}${location} failed.\n${failure.message}`,
1255
+ };
854
1256
  }
855
1257
  return undefined;
856
1258
  },
857
1259
  };
858
1260
  };
859
1261
 
860
- const withHeadline = (error: unknown, headline: string) =>
861
- error instanceof TlaEvaluationError
862
- ? setExitCode(
863
- new TlaEvaluationError(`${headline}\n${error.message}`, error),
864
- getErrorExitCode(error),
865
- )
866
- : error;
1262
+ // TLC exits with the code of a standard module's failure only when the failure escapes the
1263
+ // computation of next states. In every other phase, the phase decides the code.
1264
+ const withNextStateExitCode = (error: unknown) =>
1265
+ error instanceof TlaModuleError ? setExitCode(error, error.exitCode) : error;
1266
+
1267
+ // Stops a replay where TLC stops it without a failure, as at a violated invariant.
1268
+ const STOP_REPLAY = new Error("The replay stopped");
1269
+
1270
+ // The codes of the errors in the configuration and the spec that TLC's EC.ExitStatus maps to a
1271
+ // configuration error.
1272
+ const CONFIG_ERROR_CODES = new Set([
1273
+ ...Array.from({ length: 24 }, (_, index) => 2222 + index),
1274
+ 2272,
1275
+ 2273,
1276
+ 2274,
1277
+ 2280,
1278
+ 2281,
1279
+ ]);
1280
+
1281
+ // When TLC's replay of the initial states doesn't fail again, it exits with the code of the
1282
+ // TLCRuntimeException it reported.
1283
+ const getInitialExitCode = (error: TlaEvaluationError) => {
1284
+ const coded = getCodedMessage(error.message);
1285
+ return coded && !coded.isEvalException && CONFIG_ERROR_CODES.has(coded.code)
1286
+ ? EXIT_STATUS.configParseError
1287
+ : getErrorExitCode(error);
1288
+ };
1289
+
1290
+ // When TLC's replay of an error fails again, an EvalException from a standard module's Java code
1291
+ // decides the exit status, and any other failure exits as a nested expression failure. An error
1292
+ // that heads or wraps another exits as the other.
1293
+ const getReplayExitCode = (error: TlaEvaluationError): number => {
1294
+ const inner = error.cause;
1295
+ if (inner instanceof TlaEvaluationError) return getReplayExitCode(inner);
1296
+ return error instanceof TlaModuleError ? error.exitCode : EXIT_STATUS.specEvaluationFailure;
1297
+ };
1298
+
1299
+ // An error that TLC reports with a message of its own, by that message's code and first line, and
1300
+ // the error whose message follows.
1301
+ interface HeadedError {
1302
+ code: number;
1303
+ headline: string;
1304
+ inner: TlaEvaluationError;
1305
+ }
1306
+
1307
+ const headedErrors = new WeakMap<Error, HeadedError>();
1308
+
1309
+ const withHeadline = (error: unknown, code: number, headline: string) => {
1310
+ if (!(error instanceof TlaEvaluationError)) return error;
1311
+ const headed = setExitCode(
1312
+ new TlaEvaluationError(`${headline}\n${error.message}`, error),
1313
+ getErrorExitCode(error),
1314
+ );
1315
+ headedErrors.set(headed, { code, headline, inner: error });
1316
+ return headed;
1317
+ };
1318
+
1319
+ const UNEXPECTED_HEADLINE = UNEXPECTED_EXCEPTION.slice(0, UNEXPECTED_EXCEPTION.indexOf("\n"));
1320
+
1321
+ // TLC 1.7.4's Worker wraps an error in adding a successor in a RuntimeException, whose message
1322
+ // names the class of the error.
1323
+ const WRAPPED_EVAL_EXCEPTION = `${UNEXPECTED_EXCEPTION}tlc2.tool.EvalException: `;
1324
+ const WRAPPED_RUNTIME_EXCEPTION = `${UNEXPECTED_EXCEPTION}util.Assert$TLCRuntimeException: `;
1325
+
1326
+ const UNEXPECTED_EVAL_EXCEPTION = getUnexpectedException("tlc2.tool.EvalException");
867
1327
 
1328
+ const getWrappedException = (error: TlaEvaluationError) =>
1329
+ isEvalException(error) ? WRAPPED_EVAL_EXCEPTION : WRAPPED_RUNTIME_EXCEPTION;
1330
+
1331
+ // TLC reports an EvalException, or a TLCRuntimeException without a message of its own, as an
1332
+ // exception it didn't expect.
1333
+ const withUnexpectedException = <Result>(compute: () => Result) => {
1334
+ try {
1335
+ return compute();
1336
+ } catch (error) {
1337
+ if (!(error instanceof TlaEvaluationError)) throw error;
1338
+ if (isEvalException(error)) {
1339
+ throw new TlaEvaluationError(`${UNEXPECTED_EVAL_EXCEPTION}${error.message}`);
1340
+ }
1341
+ if (getCodedMessage(error.message)) throw error;
1342
+ throw new TlaEvaluationError(`${UNEXPECTED_EXCEPTION}${error.message}`);
1343
+ }
1344
+ };
1345
+
1346
+ // The starts of TLC's messages for the exceptions it didn't expect.
1347
+ const UNEXPECTED_EXCEPTIONS = [
1348
+ WRAPPED_EVAL_EXCEPTION,
1349
+ WRAPPED_RUNTIME_EXCEPTION,
1350
+ UNEXPECTED_EXCEPTION,
1351
+ UNEXPECTED_EVAL_EXCEPTION,
1352
+ ];
1353
+
1354
+ // The text of an error's message, with the message of a coded error inside it marked in -tool
1355
+ // output as TLC marks it.
1356
+ const formatErrorMessage = (error: TlaEvaluationError, isTool: boolean): string => {
1357
+ const headed = headedErrors.get(error);
1358
+ if (headed) return `${headed.headline}\n${formatErrorMessage(headed.inner, isTool)}`;
1359
+ const message = error.message;
1360
+ const prefix = UNEXPECTED_EXCEPTIONS.find((start) => message.startsWith(start)) ?? "";
1361
+ return `${prefix}${formatNestedMessage(message.slice(prefix.length), isTool)}`;
1362
+ };
1363
+
1364
+ // How TLC reports an error: with the code of its own message for an error that it reports with a
1365
+ // headline; and, when the error escapes the computation of next states, with the code of an
1366
+ // EvalException, or as an unexpected exception for any other error.
1367
+ interface FailureMessage {
1368
+ code: number;
1369
+ message: string;
1370
+ toolMessage: string;
1371
+ }
1372
+
1373
+ const getFailureMessage = (error: TlaEvaluationError, isNextState: boolean): FailureMessage => {
1374
+ const headed = headedErrors.get(error);
1375
+ const message = error.message;
1376
+ if (headed) {
1377
+ return {
1378
+ code: headed.code,
1379
+ message,
1380
+ toolMessage: formatErrorMessage(error, true),
1381
+ };
1382
+ }
1383
+ if (isNextState && isEvalException(error)) {
1384
+ return {
1385
+ code: getCodedMessage(message)?.code ?? MESSAGE_CODE.general,
1386
+ message,
1387
+ toolMessage: message,
1388
+ };
1389
+ }
1390
+ const isUnexpected = isNextState && !message.startsWith(UNEXPECTED_HEADLINE);
1391
+ const prefix = isUnexpected ? UNEXPECTED_EXCEPTION : "";
1392
+ return {
1393
+ code: MESSAGE_CODE.general,
1394
+ message: `${prefix}${message}`,
1395
+ toolMessage: `${prefix}${formatErrorMessage(error, true)}`,
1396
+ };
1397
+ };
1398
+
1399
+ // TLC finishes the -dump file whether or not the search finds a violation.
868
1400
  export const checkSequentially = (options: CheckOptions): CheckResult => {
869
- setNextStatePhase(false);
870
- const config = typeof options.config === "string" ? parseConfig(options.config) : options.config;
1401
+ const stateWriter =
1402
+ options.dump && createStateWriter(options.dump, options.writeFile, options.version);
1403
+ try {
1404
+ return searchStates(options, stateWriter);
1405
+ } catch (error) {
1406
+ // TLC reports a stack overflow outside the search on its own, and exits with 255.
1407
+ throw isStackOverflow(error) ? createStackOverflowError() : error;
1408
+ } finally {
1409
+ stateWriter?.close();
1410
+ }
1411
+ };
1412
+
1413
+ const createStackOverflowError = () => setExitCode(new TlaStackOverflowError(), EXIT_STATUS.error);
1414
+
1415
+ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefined): CheckResult => {
1416
+ const config =
1417
+ typeof options.config === "string"
1418
+ ? parseConfig(options.config, options.version)
1419
+ : options.config;
871
1420
  const onPrint = options.onPrint ?? console.log;
872
- // TLC prints again while it rebuilds a trace, between the states it prints. Printing those lines
873
- // before the trace would misplace them, so rebuilding a trace prints nothing.
874
- const output = { isMuted: false };
1421
+ // TLC prints again while it rebuilds a trace, between the states it prints, so rebuilding a trace
1422
+ // keeps what it prints for the trace.
1423
+ const output = { lines: undefined as OutputLine[] | undefined };
875
1424
  const print = (text: string) => {
876
- if (!output.isMuted) onPrint(text);
1425
+ if (output.lines) output.lines.push(text);
1426
+ else onPrint(text);
877
1427
  };
878
- const withoutOutput = <Result>(rebuild: () => Result) => {
879
- output.isMuted = true;
880
- const result = rebuild();
881
- output.isMuted = false;
882
- return result;
1428
+ const getOutput = <Result>(rebuild: () => Result) => {
1429
+ const outer = output.lines;
1430
+ const lines: OutputLine[] = [];
1431
+ output.lines = lines;
1432
+ try {
1433
+ return { result: rebuild(), lines };
1434
+ } finally {
1435
+ output.lines = outer;
1436
+ }
883
1437
  };
884
1438
  setStringOrder(getTlcStringOrder(options.source, config, options.loadModule));
1439
+ setValueVersion(options.version);
885
1440
  const specification = createEnvironment(config, {
886
1441
  source: options.source,
887
1442
  loadModule: options.loadModule,
@@ -889,9 +1444,16 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
889
1444
  print,
890
1445
  files: { readFile: options.readFile, writeFile: options.writeFile },
891
1446
  seed: options.seed,
1447
+ isTool: options.isTool,
1448
+ isTraceRecorded: options.isTraceRecorded,
1449
+ isSanyReported: options.isSanyReported,
1450
+ isWarningEnabled: options.isWarningEnabled,
1451
+ version: options.version,
892
1452
  });
1453
+ reportStartup(specification, config, options.onProgress);
893
1454
  const environment = specification.environment;
894
1455
  const runtime = environment.runtime;
1456
+ const is174 = runtime.version === "1.7.4";
895
1457
  runtime.pause = options.onPause ?? (() => {});
896
1458
  runtime.getSpecification = () =>
897
1459
  getSpecificationValue(
@@ -900,7 +1462,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
900
1462
  specification.variableLocations,
901
1463
  specification.instanceActions,
902
1464
  );
903
- const statistics = { depth: 0 };
1465
+ const statistics = { depth: 0, initialStates: undefined as InitialStates | undefined };
904
1466
  const createResult = (
905
1467
  status: CheckStatus,
906
1468
  violation?: Omit<Violation, "loopStart"> & { loopStart?: number },
@@ -913,15 +1475,26 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
913
1475
  distinctStates: runtime.distinctStates,
914
1476
  queuedStates: runtime.queueSize,
915
1477
  depth: runtime.generatedStates === 0 ? 0 : Math.max(statistics.depth, 1),
1478
+ initialStates: statistics.initialStates,
916
1479
  outDegrees: undefined,
917
1480
  fingerprintDistance: undefined,
918
1481
  });
919
1482
  const outDegrees = Array.from({ length: OUT_DEGREE_BUCKETS }, () => 0);
920
1483
  const expansion = { newStates: 0 };
921
1484
  const getOutDegreeBucket = () => Math.min(expansion.newStates, OUT_DEGREE_BUCKETS - 1);
922
- // TLC counts the state it was expanding when an evaluation failed.
1485
+ // TLC counts the state it was expanding when an evaluation failed, except TLC 1.7.4, whose
1486
+ // worker stops before it counts the state.
923
1487
  const getPartialOutDegrees = () =>
924
1488
  outDegrees.map((count, degree) => (degree === getOutDegreeBucket() ? count + 1 : count));
1489
+ const getFailureOutDegrees = () => (is174 ? [...outDegrees] : getPartialOutDegrees());
1490
+ // TLC 1.7.4 doesn't name the properties a counterexample violates, so it evaluates none of them.
1491
+ const getViolatedProperties = (checker: LivenessChecker, path: Value[][], cycleStart: number) =>
1492
+ is174 ? [] : checker.getViolatedProperties(path, cycleStart);
1493
+ // A violation in a successor ends the expansion of a state before TLC counts it.
1494
+ const withOutDegrees = (result: CheckResult, degrees = [...outDegrees]): CheckResult => ({
1495
+ ...result,
1496
+ violationOutDegrees: degrees,
1497
+ });
925
1498
  const createSuccess = (): CheckResult => ({
926
1499
  ...createResult("success"),
927
1500
  outDegrees: [...outDegrees],
@@ -935,36 +1508,252 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
935
1508
  ),
936
1509
  });
937
1510
 
938
- const search = createSearch(config, environment, () =>
939
- getTlcVariableOrder(options.source, options.loadModule),
1511
+ const search = createSearch(
1512
+ config,
1513
+ environment,
1514
+ () => getTlcVariableOrder(options.source, options.loadModule),
1515
+ options.onProgress,
940
1516
  );
941
- const assumptionViolation = findAssumptionViolation(specification.assumptions, environment);
942
- if (assumptionViolation) return createResult("assumption-violation", assumptionViolation);
943
- if (!search) return createSuccess();
1517
+ const findViolatedAssumption = () =>
1518
+ findAssumptionViolation(specification.assumptions, environment);
1519
+ if (!search) {
1520
+ runtime.isStarted = true;
1521
+ const assumptionViolation = findViolatedAssumption();
1522
+ if (assumptionViolation) return createResult("assumption-violation", assumptionViolation);
1523
+ // TLC computes the initial states of a spec without variables, of which there are none.
1524
+ statistics.initialStates = { generated: 0, distinct: 0 };
1525
+ options.onProgress?.({ kind: "initial-states-started" });
1526
+ options.onProgress?.({
1527
+ kind: "initial-states-computed",
1528
+ initialStates: statistics.initialStates,
1529
+ });
1530
+ return createSuccess();
1531
+ }
944
1532
  const hasPostconditions = config.postconditions.length > 0 || config.possible.length > 0;
945
- const reportViolation = (
946
- status: CheckStatus,
947
- violation: Omit<Violation, "loopStart"> & { loopStart?: number },
948
- getLoopAction?: () => string | undefined,
1533
+ // The state of each step of a trace without the alias, and the action TLC finds for the step,
1534
+ // which CounterExample records.
1535
+ const traceSteps = new WeakMap<
1536
+ TraceStep,
1537
+ { state: Record<string, Value>; action: SpecAction | undefined }
1538
+ >();
1539
+ const getStepState = (step: TraceStep) => traceSteps.get(step)?.state ?? step.state;
1540
+ const getStepAction = (step: TraceStep) => {
1541
+ const action = traceSteps.get(step)?.action;
1542
+ return action ? toActionValue(action) : createActionRecord(step.action);
1543
+ };
1544
+ // Worker#printTrace checks the postconditions on the CounterExample of each trace it prints, so
1545
+ // what they print follows the trace.
1546
+ const checkTracePostconditions = (
1547
+ trace: TraceStep[],
1548
+ loop: { start: number; action: Value } | undefined,
949
1549
  ) => {
950
1550
  if (hasPostconditions) {
951
- const start = violation.loopStart;
952
1551
  runtime.counterExample = createCounterExample(
953
- violation.trace,
954
- start === undefined || !getLoopAction ? undefined : { start, action: getLoopAction() },
1552
+ trace.map(getStepState),
1553
+ trace.slice(1).map(getStepAction),
1554
+ loop,
955
1555
  );
956
1556
  }
957
1557
  const unwitnessed = search.findUnwitnessedPossible();
958
- if (!unwitnessed) search.findPostconditionViolation();
959
- return createResult(status, unwitnessed ? { ...violation, unwitnessed } : violation);
1558
+ const checked = unwitnessed
1559
+ ? { result: undefined, lines: [] }
1560
+ : getOutput(() => search.findPostconditionViolation(true));
1561
+ return { unwitnessed, postcondition: checked.result, lines: checked.lines };
1562
+ };
1563
+ const reportViolation = (
1564
+ status: CheckStatus,
1565
+ violation: Omit<Violation, "loopStart"> & { loopStart?: number },
1566
+ getLoopAction?: () => Value,
1567
+ ) => {
1568
+ const start = violation.loopStart;
1569
+ const checked = checkTracePostconditions(
1570
+ violation.trace,
1571
+ start === undefined || !getLoopAction ? undefined : { start, action: getLoopAction() },
1572
+ );
1573
+ const traceOutput = [...(violation.traceOutput ?? []), ...checked.lines];
1574
+ return createResult(status, {
1575
+ ...violation,
1576
+ ...(traceOutput.length > 0 && { traceOutput }),
1577
+ ...(checked.unwitnessed && { unwitnessed: checked.unwitnessed }),
1578
+ ...(checked.postcondition && { postcondition: checked.postcondition }),
1579
+ });
960
1580
  };
961
1581
  const spec = search.spec;
962
1582
  const getFingerprintState = search.getFingerprintState;
963
1583
  const nextActions = { value: undefined as SpecAction[] | undefined };
1584
+ const getSpecNextActions = () =>
1585
+ (nextActions.value ??= getNextActions(config, environment, specification.instanceActions));
1586
+ // Where TLC's replay of a failed computation fails, or undefined when the replay completes.
1587
+ const getReplayFailure = (replay: (tracing: Environment) => void): ReplayFailure | undefined => {
1588
+ const tracing = createTracingEnvironment(environment);
1589
+ const callStack = tracing.callStack;
1590
+ try {
1591
+ replay(tracing);
1592
+ return undefined;
1593
+ } catch (error) {
1594
+ // A replay that overflows the stack again has an empty call stack.
1595
+ if (isStackOverflow(error)) return { callStack: [], fingerprint: undefined };
1596
+ if (!(error instanceof TlaEvaluationError) || !callStack) return undefined;
1597
+ return { callStack: callStack.expressions, fingerprint: callStack.fingerprint };
1598
+ }
1599
+ };
1600
+ // The sources of the values a fingerprint fails inside, outermost first: each value fails as it
1601
+ // fingerprints a value it holds.
1602
+ const findFailedSources = (value: Value, sources: CallStack["sources"]): Expression[] => {
1603
+ if (typeof value !== "object") return [];
1604
+ const source = sources.get(value);
1605
+ const failed = getHeldValues(value).find((held) => getFingerprintError(held) !== undefined);
1606
+ return [
1607
+ ...(source ? [source] : []),
1608
+ ...(failed === undefined ? [] : findFailedSources(failed, sources)),
1609
+ ];
1610
+ };
1611
+ // TLC's replay fingerprints the states it finds, and a value the replay built raises a
1612
+ // FingerprintException when it fails to.
1613
+ const fingerprintReplayed = (state: Value[], callStack: CallStack | undefined) => {
1614
+ for (const value of getFingerprintState(state)) {
1615
+ const error = getFingerprintError(value);
1616
+ if (!error) continue;
1617
+ const sources = callStack ? findFailedSources(value, callStack.sources) : [];
1618
+ // TLC fingerprints a state outside any evaluation, so its call stack is empty.
1619
+ if (callStack && sources.length > 0) {
1620
+ callStack.expressions.length = 0;
1621
+ callStack.isFrozen = true;
1622
+ callStack.fingerprint = { sources, reason: error.message };
1623
+ }
1624
+ throw error;
1625
+ }
1626
+ state.forEach(markFingerprinted);
1627
+ };
1628
+ // The replay adds the states it hasn't seen to TLC's set of states, which already holds the state
1629
+ // that failed after TLC added it.
1630
+ const createReplayedStates = () => {
1631
+ const replayed = unstoredState.fingerprint ? [unstoredState.fingerprint] : [];
1632
+ return (state: Value[], callStack: CallStack | undefined) => {
1633
+ fingerprintReplayed(state, callStack);
1634
+ const fingerprintState = getFingerprintState(state);
1635
+ const isSeen =
1636
+ findStateIndex(getStateHash(fingerprintState), fingerprintState) !== -1 ||
1637
+ replayed.some((seen) => isSameState(seen, fingerprintState));
1638
+ if (isSeen) return false;
1639
+ replayed.push(fingerprintState);
1640
+ runtime.distinctStates++;
1641
+ return true;
1642
+ };
1643
+ };
1644
+ // TLC's DoInitFunctor reports its progress again as it replays the initial states, and adds each
1645
+ // one it hasn't seen to the behavior graph. After a FingerprintException, it only counts the
1646
+ // states left, then throws the exception.
1647
+ const replayInit = () => {
1648
+ const replayed = { count: 0 };
1649
+ const deferred: TlaEvaluationError[] = [];
1650
+ const addReplayed = createReplayedStates();
1651
+ return getReplayFailure((tracing) => {
1652
+ replayInitialStates(
1653
+ getInitActions(config, environment, specification.instanceActions),
1654
+ tracing,
1655
+ (state) => {
1656
+ reportInitialStatesProgress(replayed.count, (progress) => output.lines?.push(progress));
1657
+ replayed.count++;
1658
+ runtime.generatedStates = replayed.count;
1659
+ if (deferred.length > 0) return;
1660
+ try {
1661
+ const addFingerprint = () => {
1662
+ if (!addReplayed(state, tracing.callStack)) return;
1663
+ runtime.queueSize++;
1664
+ liveness?.addInitialState(states.length, state, tracing);
1665
+ };
1666
+ const violation = search.checkReplayedInitialState(state, tracing, addFingerprint);
1667
+ if (violation) {
1668
+ const traced = toTrace([{ action: undefined, state }], []).trace[0].state;
1669
+ output.lines?.push({ kind: "initial-state-violation", ...violation, state: traced });
1670
+ throw STOP_REPLAY;
1671
+ }
1672
+ } catch (error) {
1673
+ if (!(error instanceof TlaEvaluationError) || !tracing.callStack?.fingerprint) {
1674
+ throw error;
1675
+ }
1676
+ deferred.push(error);
1677
+ }
1678
+ },
1679
+ );
1680
+ if (deferred.length > 0) throw deferred[0];
1681
+ });
1682
+ };
1683
+ // TLC replays the expansion of a state with ModelChecker.doNext, which writes each successor in
1684
+ // the model to the -dump state graph again.
1685
+ const replayNext = (index: number) =>
1686
+ getReplayFailure((tracing) => {
1687
+ const state = states[index];
1688
+ const source = stateWriter && getGraphState(state, depths[index]);
1689
+ const addReplayed = createReplayedStates();
1690
+ replaySuccessors(getSpecNextActions(), state, tracing, (next, action) => {
1691
+ const addFingerprint = () => {
1692
+ const isUnseen = addReplayed(next, tracing.callStack);
1693
+ if (source) {
1694
+ stateWriter?.writeSuccessor(
1695
+ source,
1696
+ getGraphState(next, depths[index] + 1),
1697
+ !isUnseen,
1698
+ isNamingEdges
1699
+ ? { name: action.name, signature: getActionSignature(action) }
1700
+ : undefined,
1701
+ );
1702
+ }
1703
+ return isUnseen;
1704
+ };
1705
+ if (!search.checkReplayedSuccessor(state, next, tracing, addFingerprint)) {
1706
+ throw STOP_REPLAY;
1707
+ }
1708
+ });
1709
+ });
964
1710
  const isReducing = config.view !== undefined || config.symmetry !== undefined;
1711
+ const tlcFingerprints: number[] = [];
1712
+ // TLC warns about the liveness checker before it builds it.
1713
+ if (search.properties.liveness.length > 0) {
1714
+ options.onProgress?.({
1715
+ kind: "liveness-initializing",
1716
+ isSymmetric: search.isSymmetric,
1717
+ isConstrained: search.isConstrained,
1718
+ });
1719
+ }
965
1720
  const liveness = withLivenessExitCode(() =>
966
- createLivenessChecker(search.properties.liveness, spec.temporals, environment),
1721
+ withUnexpectedException(() =>
1722
+ createLivenessChecker(search.properties.liveness, spec.temporals, environment, {
1723
+ getFingerprint: ({ index, state }) =>
1724
+ (tlcFingerprints[index] ??= Number(BigInt.asIntN(32, runtime.getFingerprint(state)))),
1725
+ getSuccessors: (source, state) => {
1726
+ const successors: LiveSuccessor[] = [];
1727
+ if (spec.next === undefined) return successors;
1728
+ // The constraints read the level of the state whose successors they check, as when TLC
1729
+ // explored it.
1730
+ const livenessSource = current.livenessSource;
1731
+ current.livenessSource = source;
1732
+ forEachSuccessor(
1733
+ spec.next,
1734
+ state,
1735
+ environment,
1736
+ (successor) => {
1737
+ canonicalizeState(successor.state);
1738
+ const isInModel =
1739
+ search.satisfiesConstraints(successor.state, state) &&
1740
+ search.satisfiesActionConstraints(state, successor.state);
1741
+ if (!isInModel) return false;
1742
+ const fingerprintState = getFingerprintState(successor.state);
1743
+ const index = findStateIndex(getStateHash(fingerprintState), fingerprintState);
1744
+ successors.push({ index, state: successor.state });
1745
+ return false;
1746
+ },
1747
+ spec.scope,
1748
+ );
1749
+ current.livenessSource = livenessSource;
1750
+ return successors;
1751
+ },
1752
+ }),
1753
+ ),
967
1754
  );
1755
+ // TLC 1.7.4 creates its model checker, which TLCGet reads, once it has built the liveness checker.
1756
+ runtime.isStarted = true;
968
1757
  const isCanonicalizedFirst = search.isSymmetric || liveness !== undefined;
969
1758
 
970
1759
  const states: Value[][] = [];
@@ -972,7 +1761,9 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
972
1761
  const parents: number[] = [];
973
1762
  const actions: (string | undefined)[] = [];
974
1763
  const depths: number[] = [];
975
- const buckets = new Map<number, number | number[]>();
1764
+ // A Map holds at most 2^24 entries, so an open-addressing table keeps each seen state's hash
1765
+ // and its index plus one side by side, probed by the hash.
1766
+ const seen = { slots: new Int32Array(1 << 17), size: 0, shift: 16 };
976
1767
  const canonicalizeState = createCanonicalizer();
977
1768
 
978
1769
  const toRecord = (state: Value[]): Record<string, Value> =>
@@ -985,11 +1776,16 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
985
1776
  position: number,
986
1777
  loopStart: number | undefined,
987
1778
  ) => {
988
- const state = steps[position].state;
989
- const next = (steps[position + 1] ?? steps[loopStart ?? position]).state;
990
1779
  // TLC evaluates TLCGet("level") and Trace in an alias at the state's position in the trace.
991
1780
  runtime.getLevel = () => position + 1;
992
1781
  runtime.getBehavior = () => steps.slice(0, position + 1).map((step) => step.state);
1782
+ return evaluateAlias(
1783
+ alias,
1784
+ steps[position].state,
1785
+ (steps[position + 1] ?? steps[loopStart ?? position]).state,
1786
+ );
1787
+ };
1788
+ const evaluateAlias = (alias: string, state: Value[], next: Value[] | undefined) => {
993
1789
  try {
994
1790
  const body = getConfigDefinition("alias", alias, environment).body;
995
1791
  const value = evaluate(createIdentifier(alias), getContext(environment, state, next));
@@ -997,58 +1793,107 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
997
1793
  return toAliasRecord(value, fieldOrder) ?? toRecord(state);
998
1794
  } catch (error) {
999
1795
  if (!(error instanceof TlaConfigError || error instanceof TlaEvaluationError)) throw error;
1000
- return { ...toRecord(state), _ALIASEvalError: error.message };
1796
+ return {
1797
+ ...toRecord(state),
1798
+ _ALIASEvalError: formatNestedMessage(error.message, options.isTool ?? false),
1799
+ };
1001
1800
  }
1002
1801
  };
1003
- // TLC labels a step with the first action that takes it, evaluated as when the search expanded
1004
- // the previous state.
1005
- const getLabel = (index: number, previous: Value[], state: Value[]) => {
1006
- nextActions.value ??= getNextActions(config, environment, specification.instanceActions);
1802
+ // TLC finds the action of a step as the first action that takes it, evaluated as when the search
1803
+ // expanded the previous state.
1804
+ // TLC finds the action of a successor it holds by the successor's values, and of any other state
1805
+ // by its fingerprint.
1806
+ const findStepAction = (index: number, previous: Value[], state: Value[], isHeld: boolean) => {
1807
+ const actions = getSpecNextActions();
1007
1808
  const expanding = { ...current };
1008
1809
  Object.assign(current, { index, isExpanding: true, candidate: undefined });
1009
- const fingerprintState = getFingerprintState(state);
1010
- const action = nextActions.value.find((item) =>
1810
+ const getKey = isHeld ? (values: Value[]) => values : getFingerprintState;
1811
+ const key = getKey(state);
1812
+ const action = actions.find((item) =>
1011
1813
  getSuccessors(item.expression, previous, environment, item.scope).some((successor) =>
1012
- isSameState(getFingerprintState(successor.state), fingerprintState),
1814
+ isSameState(getKey(successor.state), key),
1013
1815
  ),
1014
1816
  );
1015
1817
  Object.assign(current, expanding);
1016
- return action && getActionLabel(action);
1818
+ return action;
1017
1819
  };
1018
- const toTrace = (steps: Successor[], path: number[], loopStart?: number): TraceStep[] => {
1820
+ // Before TLC prints a trace, it rebuilds from the initial predicate the states it does not keep,
1821
+ // all but the last `known` ones. As it prints each later step, it finds the action that takes
1822
+ // the step. Then it rebuilds the trace once more, unless the trace is a liveness counterexample
1823
+ // or TLC is 1.7.4.
1824
+ const toTrace = (
1825
+ steps: Successor[],
1826
+ path: number[],
1827
+ traceOptions: TraceOptions = {},
1828
+ ): Behavior => {
1019
1829
  const alias = config.alias;
1020
- const labels = withoutOutput(() => {
1021
- // TLC rebuilds a trace from the initial predicate, which can reset what TLCSet stored.
1022
- if (steps.length > 1 && isImpure(environment)) getSpecInitialStates();
1023
- // TLC finds the action that takes each step before it evaluates the alias.
1024
- return steps.map((step, position) =>
1025
- position === 0 || step.action === "Stuttering"
1026
- ? undefined
1027
- : getLabel(path[position - 1], steps[position - 1].state, step.state),
1028
- );
1029
- });
1030
- return steps.map((step, position) => ({
1031
- action: step.action,
1032
- label: labels[position],
1033
- state:
1034
- alias === undefined
1035
- ? toRecord(step.state)
1036
- : getAliasState(alias, steps, position, loopStart),
1037
- }));
1830
+ const known = traceOptions.known ?? 1;
1831
+ // Rebuilding the trace from the initial predicate can reset what TLCSet stored.
1832
+ const initialOutput = steps.length > 1 ? getOutput(getSpecInitialStates).lines : [];
1833
+ // TLC finds the action that takes each step before it evaluates the alias.
1834
+ const found = steps.map((step, position) =>
1835
+ position === 0 || step.action === "Stuttering"
1836
+ ? { result: undefined, lines: [] }
1837
+ : getOutput(() =>
1838
+ findStepAction(
1839
+ path[position - 1],
1840
+ steps[position - 1].state,
1841
+ step.state,
1842
+ known === 2 && position === steps.length - 1,
1843
+ ),
1844
+ ),
1845
+ );
1846
+ const outputs = found.map((step) => step.lines);
1847
+ const loopStart = traceOptions.loopStart;
1848
+ // 1.7.4's LiveWorker#printTrace rebuilds a lasso up to the start of its cycle at once, and then
1849
+ // each state of the cycle as it prints it.
1850
+ const rebuilt = is174 && loopStart !== undefined ? loopStart + 1 : steps.length - known;
1851
+ const prefixOutput = rebuilt > 0 ? [initialOutput, ...outputs.slice(1, rebuilt)].flat() : [];
1852
+ return {
1853
+ trace: steps.map((step, position) => {
1854
+ const action = found[position].result;
1855
+ const traceStep: TraceStep = {
1856
+ action: step.action,
1857
+ label: action && getActionLabel(action, options.version),
1858
+ state:
1859
+ alias === undefined
1860
+ ? toRecord(step.state)
1861
+ : getAliasState(alias, steps, position, loopStart),
1862
+ output: position === 0 ? prefixOutput : position < rebuilt ? [] : outputs[position],
1863
+ };
1864
+ if (alias !== undefined || action) {
1865
+ traceSteps.set(traceStep, { state: toRecord(step.state), action });
1866
+ }
1867
+ return traceStep;
1868
+ }),
1869
+ traceOutput: known > 0 && !is174 ? [initialOutput, ...outputs].flat() : [],
1870
+ };
1038
1871
  };
1039
1872
  const getSpecInitialStates = () =>
1040
1873
  spec.init === undefined ? [] : getInitialStates(spec.init, environment, spec.scope);
1041
- const getTraceSuccessors = (state: Value[]) =>
1042
- spec.next === undefined ? [] : getSuccessors(spec.next, state, environment, spec.scope);
1874
+ // TLC's Tool#getState rebuilds a successor action by action, up to the first action that
1875
+ // generates it. A trace keeps what the spec prints as TLC rebuilds it, so finding its states
1876
+ // prints nothing.
1877
+ const findTraceSuccessor = (state: Value[], isMatch: (successor: Successor) => boolean) =>
1878
+ getOutput(() => {
1879
+ for (const action of getSpecNextActions()) {
1880
+ const successor = getSuccessors(action.expression, state, environment, action.scope).find(
1881
+ isMatch,
1882
+ );
1883
+ if (successor) return { ...successor, action: successor.action ?? action.name };
1884
+ }
1885
+ return undefined;
1886
+ }).result;
1043
1887
  const hasFingerprint = (state: Value[], index: number) =>
1044
1888
  isSameState(getFingerprintState(state), fingerprintStates[index]);
1045
1889
  const findSuccessorWithFingerprint = (state: Value[], index: number) =>
1046
- getTraceSuccessors(state).find((successor) => hasFingerprint(successor.state, index));
1890
+ findTraceSuccessor(state, (successor) => hasFingerprint(successor.state, index));
1047
1891
  const getPathStates = (path: number[], nextFailure: string) => {
1048
- const initial =
1892
+ const initial = getOutput(() =>
1049
1893
  isReducing || isImpure(environment)
1050
1894
  ? getSpecInitialStates().find((state) => hasFingerprint(state, path[0]))
1051
- : states[path[0]];
1895
+ : states[path[0]],
1896
+ ).result;
1052
1897
  if (!initial) throw new TlaEvaluationError(INITIAL_RECOVERY_FAILURE);
1053
1898
  const steps: Successor[] = [{ state: initial, action: undefined }];
1054
1899
  for (let position = 1; position < path.length; position++) {
@@ -1074,37 +1919,120 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1074
1919
  : path.map((position) => ({ state: states[position], action: actions[position] }));
1075
1920
  if (!last) return toTrace(steps, path);
1076
1921
  const action = isReducing
1077
- ? getTraceSuccessors(states[index]).find((successor) =>
1078
- isSameState(successor.state, last.state),
1079
- )?.action
1922
+ ? findTraceSuccessor(states[index], (successor) => isSameState(successor.state, last.state))
1923
+ ?.action
1080
1924
  : last.action;
1081
- return toTrace([...steps, { state: last.state, action }], path);
1925
+ return toTrace([...steps, { state: last.state, action }], path, { known: 2 });
1082
1926
  };
1083
1927
  // TLC prints an initial state on its own without evaluating the alias.
1084
- const getStateTrace = (index: number) =>
1928
+ // TLCTrace#getTrace recovers even a lone initial state from the initial predicate, printing
1929
+ // again, though TLC 1.7.4 doesn't.
1930
+ const getStateTrace = (index: number): Behavior =>
1085
1931
  parents[index] === -1
1086
- ? [{ action: undefined, label: undefined, state: toRecord(states[index]) }]
1932
+ ? {
1933
+ trace: [{ action: undefined, label: undefined, state: toRecord(states[index]) }],
1934
+ traceOutput: is174 ? [] : getOutput(getSpecInitialStates).lines,
1935
+ }
1087
1936
  : getTrace(index);
1937
+ // TLC rebuilds the trace again for the postcondition after it prints a violation, but not after
1938
+ // an evaluation fails.
1939
+ const getFailedTrace = (index: number, successor: Successor): Behavior => ({
1940
+ trace: getTrace(index, successor).trace,
1941
+ });
1088
1942
  // TLC names the initial state it was checking unless a standard module's Java code failed.
1089
- const toFailure = (
1090
- error: unknown,
1091
- trace: TraceStep[],
1092
- initialState?: Value[],
1093
- failureOutDegrees?: number[],
1094
- ) => {
1943
+ const getFailureExitCode = (error: TlaEvaluationError, failureOptions: FailureOptions) => {
1944
+ // TLC 1.7.4 exits with the result of its replay of the initial states, which only fails again
1945
+ // when the error isn't in adding a state it has already seen to the behavior graph.
1946
+ if (
1947
+ failureOptions.isInitial &&
1948
+ !failureOptions.callStack &&
1949
+ !failureOptions.fingerprint &&
1950
+ is174
1951
+ ) {
1952
+ return EXIT_STATUS.success;
1953
+ }
1954
+ if (!failureOptions.callStack) {
1955
+ return failureOptions.isInitial ? getInitialExitCode(error) : getErrorExitCode(error);
1956
+ }
1957
+ if (failureOptions.isCallStackFirst) return getErrorExitCode(error);
1958
+ // Without a replay, TLC exits with the code of the error, as for any error it didn't expect.
1959
+ if (failureOptions.isLiveCallStack) {
1960
+ return (
1961
+ getExitCode(error) ?? (error instanceof TlaModuleError ? error.exitCode : EXIT_STATUS.error)
1962
+ );
1963
+ }
1964
+ // TLC exits with the code of a failed replay of the initial states regardless of the error, as
1965
+ // it does for a replay that fails to fingerprint.
1966
+ return failureOptions.isInitial || failureOptions.fingerprint
1967
+ ? EXIT_STATUS.specEvaluationFailure
1968
+ : getReplayExitCode(error);
1969
+ };
1970
+ const toFailure = (failed: unknown, behavior: Behavior, failureOptions: FailureOptions = {}) => {
1971
+ const error = isStackOverflow(failed) ? new TlaStackOverflowError() : failed;
1095
1972
  if (!(error instanceof TlaEvaluationError)) throw error;
1973
+ const checked =
1974
+ behavior.trace.length > 0 && !failureOptions.traceFailure
1975
+ ? checkTracePostconditions(behavior.trace, undefined)
1976
+ : undefined;
1977
+ const postcondition = checked?.unwitnessed ?? checked?.postcondition;
1978
+ const traceOutput = [...(behavior.traceOutput ?? []), ...(checked?.lines ?? [])];
1096
1979
  return {
1097
1980
  ...createResult("error", undefined, {
1098
- message: error.message,
1099
- trace,
1981
+ ...getFailureMessage(error, failureOptions.isNextState ?? false),
1982
+ ...behavior,
1983
+ ...(traceOutput.length > 0 && { traceOutput }),
1984
+ ...(postcondition && { postcondition }),
1100
1985
  initialState:
1101
- initialState && !(error instanceof TlaModuleError) ? toRecord(initialState) : undefined,
1102
- exitCode: getErrorExitCode(error),
1986
+ failureOptions.initialState && !(error instanceof TlaModuleError)
1987
+ ? toRecord(failureOptions.initialState)
1988
+ : undefined,
1989
+ exitCode: getFailureExitCode(error, failureOptions),
1990
+ callStack: failureOptions.callStack,
1991
+ ...(failureOptions.isCallStackFirst && { isCallStackFirst: true }),
1992
+ ...(failureOptions.fingerprint && { fingerprint: failureOptions.fingerprint }),
1993
+ ...(failureOptions.traceFailure && { traceFailure: failureOptions.traceFailure }),
1103
1994
  }),
1104
- outDegrees: failureOutDegrees,
1995
+ outDegrees: failureOptions.outDegrees,
1105
1996
  };
1106
1997
  };
1107
- const getPathTrace = (path: number[], loopStart?: number) => {
1998
+ // TLC reports a successor state that an action leaves incomplete with the trace to it, which ends
1999
+ // with the partial state. It names the action when the next-state relation has several.
2000
+ const reportIncompleteSuccessor = (index: number, error: TlaIncompleteSuccessorError) => {
2001
+ runtime.generatedStates++;
2002
+ const actions = getSpecNextActions();
2003
+ const action =
2004
+ actions.length === 1 ? actions[0] : actions.find((item) => item.name === error.action);
2005
+ const missing = error.variables;
2006
+ const subject =
2007
+ actions.length === 1
2008
+ ? "the next-state action"
2009
+ : `action ${error.action} of the next-state relation`;
2010
+ // TLC 1.7.4 says a variable is not assigned rather than not defined.
2011
+ const verb = is174 ? "assigned" : "defined";
2012
+ const message = `Successor state is not completely specified by ${subject}. The following variable${missing.length > 1 ? "s are" : " is"} not ${verb}: ${missing.join(", ")}.\n`;
2013
+ const undefinedValue = createModelValue("null");
2014
+ const partial = error.state.map((value) => value ?? undefinedValue);
2015
+ const failure = toFailure(error, getStateTrace(index));
2016
+ return withOutDegrees({
2017
+ ...failure,
2018
+ failure: failure.failure && {
2019
+ ...failure.failure,
2020
+ code: MESSAGE_CODE.incompleteSuccessor,
2021
+ message,
2022
+ toolMessage: message,
2023
+ exitCode: EXIT_STATUS.specEvaluationFailure,
2024
+ trace: [
2025
+ ...failure.failure.trace,
2026
+ {
2027
+ action: error.action,
2028
+ label: action && getActionLabel(action, options.version),
2029
+ state: toRecord(partial),
2030
+ },
2031
+ ],
2032
+ },
2033
+ });
2034
+ };
2035
+ const getPathSteps = (path: number[], loopStart?: number) => {
1108
2036
  const steps = getPathStates(path, NEXT_RECOVERY_FAILURE);
1109
2037
  const last = steps[steps.length - 1].state;
1110
2038
  const isClosed =
@@ -1113,7 +2041,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1113
2041
  loopStart === path.length - 1 ||
1114
2042
  findSuccessorWithFingerprint(last, path[loopStart]) !== undefined;
1115
2043
  if (!isClosed) throw new TlaEvaluationError(NEXT_RECOVERY_FAILURE);
1116
- return toTrace(steps, path, loopStart);
2044
+ return steps;
1117
2045
  };
1118
2046
  const getStateHash = (state: Value[]) => {
1119
2047
  let hash = 0x811c9dc5;
@@ -1121,26 +2049,52 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1121
2049
  hash = combineHash(hash, getValueHash(state[index]));
1122
2050
  return hash & 0x3fffffff;
1123
2051
  };
2052
+ // TLC fingerprints a state once it finds the state in the model.
2053
+ const fingerprintModelState = (state: Value[]) => {
2054
+ for (const value of state) {
2055
+ const error = getFingerprintError(value);
2056
+ if (error) throw error;
2057
+ }
2058
+ };
1124
2059
  const isSameState = (stored: Value[], state: Value[]) => {
1125
2060
  for (let position = 0; position < state.length; position++) {
1126
2061
  if (!isSameValue(stored[position], state[position])) return false;
1127
2062
  }
1128
2063
  return true;
1129
2064
  };
2065
+ const getSlot = (hash: number) => (Math.imul(hash, 0x9e3779b1) >>> seen.shift) << 1;
1130
2066
  const findStateIndex = (hash: number, state: Value[]) => {
1131
- const bucket = buckets.get(hash);
1132
- if (bucket === undefined) return -1;
1133
- if (typeof bucket === "number") {
1134
- return isSameState(fingerprintStates[bucket], state) ? bucket : -1;
2067
+ const mask = seen.slots.length - 1;
2068
+ for (let slot = getSlot(hash); ; slot = (slot + 2) & mask) {
2069
+ const entry = seen.slots[slot + 1];
2070
+ if (entry === 0) return -1;
2071
+ if (seen.slots[slot] === hash && isSameState(fingerprintStates[entry - 1], state)) {
2072
+ return entry - 1;
2073
+ }
1135
2074
  }
1136
- return bucket.find((index) => isSameState(fingerprintStates[index], state)) ?? -1;
2075
+ };
2076
+ const insertSeen = (hash: number, entry: number) => {
2077
+ const mask = seen.slots.length - 1;
2078
+ let slot = getSlot(hash);
2079
+ while (seen.slots[slot + 1] !== 0) slot = (slot + 2) & mask;
2080
+ seen.slots[slot] = hash;
2081
+ seen.slots[slot + 1] = entry;
1137
2082
  };
1138
2083
  const markSeen = (hash: number, index: number) => {
1139
- const bucket = buckets.get(hash);
1140
- if (bucket === undefined) buckets.set(hash, index);
1141
- else if (typeof bucket === "number") buckets.set(hash, [bucket, index]);
1142
- else bucket.push(index);
2084
+ seen.size++;
2085
+ if (seen.size * 4 > seen.slots.length) {
2086
+ const slots = seen.slots;
2087
+ seen.slots = new Int32Array(slots.length * 2);
2088
+ seen.shift--;
2089
+ for (let slot = 0; slot < slots.length; slot += 2) {
2090
+ if (slots[slot + 1] !== 0) insertSeen(slots[slot], slots[slot + 1]);
2091
+ }
2092
+ }
2093
+ insertSeen(hash, index + 1);
1143
2094
  };
2095
+ // A new successor that TLC has added to its set of states before it checks the successor, which
2096
+ // the check stores after.
2097
+ const unstoredState = { fingerprint: undefined as Value[] | undefined };
1144
2098
  const countDistinctState = (depth: number) => {
1145
2099
  runtime.distinctStates = states.length + 1;
1146
2100
  statistics.depth = Math.max(statistics.depth, depth);
@@ -1179,10 +2133,15 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1179
2133
  };
1180
2134
  runtime.getCurrentState = () => (current.index === -1 ? undefined : states[current.index]);
1181
2135
  runtime.setLivenessSource = (index) => {
1182
- current.livenessSource = index;
2136
+ current.livenessSource = index ?? -1;
1183
2137
  };
1184
2138
  runtime.getLevel = (state) => {
1185
2139
  const source = current.livenessSource;
2140
+ // TLC 1.7.4 reads the level of the state its worker explores, whichever state it evaluates.
2141
+ if (is174) {
2142
+ const explored = source !== -1 ? source : current.isExpanding ? current.index : -1;
2143
+ return explored === -1 ? 0 : depths[explored];
2144
+ }
1186
2145
  if (source !== -1) return state === states[source] ? depths[source] : depths[source] + 1;
1187
2146
  if (state === current.candidate) return current.candidateLevel;
1188
2147
  if (current.index === -1) return 0;
@@ -1190,6 +2149,18 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1190
2149
  return current.isExpanding ? depths[current.index] + 1 : 0;
1191
2150
  };
1192
2151
 
2152
+ const getGraphState = (state: Value[], level: number): GraphState => ({
2153
+ fingerprint: BigInt.asIntN(64, runtime.getFingerprint(state)),
2154
+ level,
2155
+ getLabel: () =>
2156
+ formatState(
2157
+ config.alias === undefined
2158
+ ? toRecord(state)
2159
+ : evaluateAlias(config.alias, state, undefined),
2160
+ ),
2161
+ getText: () => formatState(toRecord(state)),
2162
+ });
2163
+
1193
2164
  const visitInitialState = (state: Value[]) => {
1194
2165
  canonicalizeState(state);
1195
2166
  runtime.generatedStates++;
@@ -1199,26 +2170,32 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1199
2170
  const fingerprintState = getFingerprintState(state);
1200
2171
  const hash = getStateHash(fingerprintState);
1201
2172
  const isInModel = search.satisfiesConstraints(state);
1202
- if (isInModel) search.trackStatePossible(state);
2173
+ if (isInModel) {
2174
+ search.trackStatePossible(state);
2175
+ fingerprintModelState(fingerprintState);
2176
+ state.forEach(markFingerprinted);
2177
+ }
1203
2178
  const isSeen = isInModel && findStateIndex(hash, fingerprintState) !== -1;
1204
2179
  if (isSeen) return undefined;
2180
+ unstoredState.fingerprint = isInModel ? fingerprintState : undefined;
1205
2181
  if (isInModel) {
1206
2182
  countDistinctState(1);
1207
2183
  runtime.queueSize++;
1208
2184
  liveness?.addInitialState(states.length, state);
2185
+ stateWriter?.writeInitialState(getGraphState(state, 1));
1209
2186
  }
1210
2187
  const violated = search.findViolatedInvariant(state);
1211
2188
  if (violated) {
1212
2189
  return reportViolation("invariant-violation", {
1213
2190
  name: violated.name,
1214
- trace: toTrace([{ action: undefined, state }], []),
2191
+ ...toTrace([{ action: undefined, state }], []),
1215
2192
  });
1216
2193
  }
1217
2194
  const failedPredicate = search.findFailedInitialPredicate(state);
1218
2195
  if (failedPredicate) {
1219
2196
  return reportViolation("liveness-violation", {
1220
2197
  name: failedPredicate.name,
1221
- trace: toTrace([{ action: undefined, state }], []),
2198
+ ...toTrace([{ action: undefined, state }], []),
1222
2199
  });
1223
2200
  }
1224
2201
  if (!isInModel) return undefined;
@@ -1226,7 +2203,13 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1226
2203
  addState(state, fingerprintState, -1, undefined);
1227
2204
  return undefined;
1228
2205
  };
1229
- const visitSuccessor = (index: number, successor: Successor, liveSuccessors: LiveSuccessor[]) => {
2206
+ const visitSuccessor = (
2207
+ index: number,
2208
+ successor: Successor,
2209
+ liveSuccessors: LiveSuccessor[],
2210
+ source: GraphState | undefined,
2211
+ action: SpecAction | undefined,
2212
+ ) => {
1230
2213
  const state = states[index];
1231
2214
  runtime.generatedStates++;
1232
2215
  current.candidate = successor.state;
@@ -1238,14 +2221,29 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1238
2221
  const isStateInModel = search.satisfiesConstraints(successor.state, state);
1239
2222
  if (isStateInModel) search.trackStatePossible(successor.state);
1240
2223
  const isInModel = isStateInModel && search.satisfiesActionConstraints(state, successor.state);
1241
- if (isInModel) search.trackActionPossible(state, successor.state);
2224
+ if (isInModel) {
2225
+ search.trackActionPossible(state, successor.state);
2226
+ fingerprintModelState(fingerprintState);
2227
+ successor.state.forEach(markFingerprinted);
2228
+ }
1242
2229
  const existing = isInModel ? found : -1;
2230
+ if (source && isInModel) {
2231
+ stateWriter?.writeSuccessor(
2232
+ source,
2233
+ getGraphState(successor.state, depths[index] + 1),
2234
+ existing !== -1,
2235
+ action && { name: action.name, signature: getActionSignature(action) },
2236
+ );
2237
+ }
1243
2238
  if (existing !== -1 && liveness) {
1244
2239
  const stored = states[existing];
1245
2240
  const isStored = stored.every((value, position) => value === successor.state[position]);
1246
2241
  liveSuccessors.push({ index: existing, state: isStored ? stored : successor.state });
1247
2242
  }
1248
2243
  const isNew = isInModel && existing === -1;
2244
+ // TLC adds a new state to the behavior graph's successors before it checks the invariants.
2245
+ if (isNew && liveness) liveSuccessors.push({ index: states.length, state: successor.state });
2246
+ unstoredState.fingerprint = isNew ? fingerprintState : undefined;
1249
2247
  if (isNew) {
1250
2248
  countDistinctState(depths[index] + 1);
1251
2249
  expansion.newStates++;
@@ -1254,53 +2252,105 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1254
2252
  try {
1255
2253
  const violated = search.findViolatedInvariant(successor.state, state);
1256
2254
  if (violated) {
1257
- return reportViolation("invariant-violation", {
1258
- name: violated.name,
1259
- trace: getTrace(index, successor),
1260
- });
2255
+ return withOutDegrees(
2256
+ reportViolation("invariant-violation", {
2257
+ name: violated.name,
2258
+ ...getTrace(index, successor),
2259
+ }),
2260
+ );
1261
2261
  }
1262
2262
  } catch (error) {
1263
- // TLC prints the outdegree when it cannot reproduce the failure, as for an invariant here.
1264
- return toFailure(error, getTrace(index, successor), undefined, getPartialOutDegrees());
2263
+ if (isStackOverflow(error)) throw error;
2264
+ // TLC replays the expansion and skips the invariants of a state it has seen, the failed one
2265
+ // included unless the constraints exclude it. When the replay fails, TLC reports where and
2266
+ // leaves out the outdegree.
2267
+ const replay = getOutput(() => replayNext(index));
2268
+ return toFailure(
2269
+ error,
2270
+ appendTraceOutput(getFailedTrace(index, successor), replay.lines),
2271
+ replay.result ?? { outDegrees: getFailureOutDegrees() },
2272
+ );
1265
2273
  }
1266
2274
  }
1267
2275
  const violatedProperty = search.findViolatedActionProperty(state, successor.state);
1268
2276
  if (violatedProperty) {
1269
- return reportViolation("liveness-violation", {
1270
- name: violatedProperty.name,
1271
- trace: getTrace(index, successor),
1272
- });
2277
+ return withOutDegrees(
2278
+ reportViolation("liveness-violation", {
2279
+ name: violatedProperty.name,
2280
+ ...getTrace(index, successor),
2281
+ }),
2282
+ );
1273
2283
  }
1274
2284
  if (!isNew) return undefined;
1275
2285
  if (!isCanonicalizedFirst) canonicalizeState(successor.state);
1276
2286
  markSeen(hash, states.length);
1277
- if (liveness) liveSuccessors.push({ index: states.length, state: successor.state });
1278
2287
  addState(successor.state, fingerprintState, index, successor.action);
1279
2288
  runtime.queueSize++;
1280
2289
  return undefined;
1281
2290
  };
1282
2291
 
1283
2292
  const outcome: { result: CheckResult | undefined } = { result: undefined };
2293
+ if (liveness) {
2294
+ options.onProgress?.({ kind: "liveness-prepared", branches: liveness.branches });
2295
+ }
2296
+ // TLC checks the assumptions once it has built the liveness checker in ModelChecker's
2297
+ // constructor.
2298
+ const assumptionViolation = findViolatedAssumption();
2299
+ if (assumptionViolation) return createResult("assumption-violation", assumptionViolation);
2300
+ options.onProgress?.({ kind: "initial-states-started" });
1284
2301
  if (spec.init !== undefined) {
1285
2302
  try {
1286
2303
  forEachInitialState(
1287
2304
  spec.init,
1288
2305
  environment,
1289
2306
  (state) => {
2307
+ reportInitialStatesProgress(runtime.initialStates, options.onProgress);
1290
2308
  try {
1291
2309
  outcome.result = visitInitialState(state);
1292
2310
  } catch (error) {
1293
- outcome.result = toFailure(error, [], state);
2311
+ const replay = getOutput(replayInit);
2312
+ outcome.result = toFailure(
2313
+ error,
2314
+ { trace: [], traceOutput: replay.lines },
2315
+ { initialState: state, ...replay.result, isInitial: true },
2316
+ );
1294
2317
  }
1295
2318
  return outcome.result !== undefined;
1296
2319
  },
1297
2320
  spec.scope,
1298
2321
  );
1299
2322
  } catch (error) {
1300
- return toFailure(error, []);
2323
+ // TLC prints an illegal initial state with null for each variable it leaves undefined, and
2324
+ // stops before it prints the statistics.
2325
+ if (error instanceof TlaIllegalStateError) {
2326
+ const illegal = toFailure(
2327
+ error,
2328
+ { trace: [] },
2329
+ { initialState: error.state.map((value) => value ?? createModelValue("null")) },
2330
+ );
2331
+ return {
2332
+ ...illegal,
2333
+ failure: illegal.failure && { ...illegal.failure, isWithoutStatistics: true },
2334
+ };
2335
+ }
2336
+ // TLC prints the error before it replays the initial predicate with its call stack.
2337
+ const replay = getOutput(replayInit);
2338
+ return toFailure(
2339
+ error,
2340
+ { trace: [], traceOutput: replay.lines },
2341
+ { ...replay.result, isInitial: true },
2342
+ );
1301
2343
  }
1302
2344
  }
1303
2345
  if (outcome.result) return outcome.result;
2346
+ statistics.initialStates = {
2347
+ generated: runtime.initialStates,
2348
+ distinct: runtime.distinctStates,
2349
+ };
2350
+ options.onProgress?.({
2351
+ kind: "initial-states-computed",
2352
+ initialStates: statistics.initialStates,
2353
+ });
1304
2354
 
1305
2355
  const next = spec.next;
1306
2356
  if (next === undefined) {
@@ -1311,56 +2361,276 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1311
2361
  }
1312
2362
  return createSuccess();
1313
2363
  }
1314
- const expandState = (index: number) => {
2364
+ // TLC labels and colors an edge of the -dump state graph by the action that generated it. When
2365
+ // the graph names its edges, the search generates successors action by action, as TLC does.
2366
+ const isNamingEdges = Boolean(
2367
+ options.dump?.dot && (options.dump.actionLabels || options.dump.colorize),
2368
+ );
2369
+ const forEachActionSuccessor = (
2370
+ state: Value[],
2371
+ onSuccessor: (successor: Successor, action: SpecAction | undefined) => boolean,
2372
+ ) => {
2373
+ if (!isNamingEdges) {
2374
+ return forEachSuccessor(
2375
+ next,
2376
+ state,
2377
+ environment,
2378
+ (successor) => onSuccessor(successor, undefined),
2379
+ spec.scope,
2380
+ );
2381
+ }
2382
+ const progress = { isStopped: false };
2383
+ return getSpecNextActions().reduce((count, action) => {
2384
+ if (progress.isStopped) return count;
2385
+ return (
2386
+ count +
2387
+ forEachSuccessor(
2388
+ action.expression,
2389
+ state,
2390
+ environment,
2391
+ (successor) => {
2392
+ progress.isStopped = onSuccessor(successor, action);
2393
+ return progress.isStopped;
2394
+ },
2395
+ action.scope,
2396
+ )
2397
+ );
2398
+ }, 0);
2399
+ };
2400
+ // TLC's worker adds a state to the behavior graph even after its next states fail or violate a
2401
+ // property, and prints the call stack of an error in that, unless the error is a
2402
+ // FingerprintException, which the worker doesn't catch. TLC 1.7.4 prints none.
2403
+ const getLiveCallStack = (index: number, liveSuccessors: LiveSuccessor[]) => {
2404
+ if (!liveness || is174) return undefined;
2405
+ const replay = getReplayFailure((tracing) =>
2406
+ liveness.addState(index, states[index], liveSuccessors, tracing),
2407
+ );
2408
+ return replay?.callStack.length && !replay.fingerprint ? replay.callStack : undefined;
2409
+ };
2410
+ // TLC's worker adds the state to the behavior graph after it prints the trace. On an error in that,
2411
+ // it adds the state again to print the call stack instead of replaying the next-state relation,
2412
+ // which TLC 1.7.4 doesn't.
2413
+ const addFailedLiveState = (index: number, liveSuccessors: LiveSuccessor[]) => {
2414
+ try {
2415
+ liveness?.addState(index, states[index], liveSuccessors);
2416
+ return undefined;
2417
+ } catch (error) {
2418
+ if (!(error instanceof TlaEvaluationError)) throw error;
2419
+ return getLiveCallStack(index, liveSuccessors);
2420
+ }
2421
+ };
2422
+ const replayFailedNext = (index: number, liveSuccessors: LiveSuccessor[]) => {
2423
+ const live = getOutput(() => addFailedLiveState(index, liveSuccessors));
2424
+ if (live.result) {
2425
+ const result = { callStack: live.result, fingerprint: undefined, isLiveCallStack: true };
2426
+ return { result, lines: live.lines };
2427
+ }
2428
+ const replay = getOutput(() => replayNext(index));
2429
+ return { result: replay.result, lines: [...live.lines, ...replay.lines] };
2430
+ };
2431
+ // TLC reports a stack overflow while it computes next states without replaying it, with the
2432
+ // behavior up to the state it expands.
2433
+ const reportNextStateOverflow = (index: number) =>
2434
+ toFailure(createStackOverflowError(), getStateTrace(index));
2435
+ // After the trace, TLC replays the next-state relation with its call stack, printing again.
2436
+ const reportNextStateFailure = (
2437
+ error: unknown,
2438
+ index: number,
2439
+ liveSuccessors: LiveSuccessor[],
2440
+ ) => {
2441
+ if (isStackOverflow(error)) return reportNextStateOverflow(index);
2442
+ const replay = replayFailedNext(index, liveSuccessors);
2443
+ return toFailure(
2444
+ withNextStateExitCode(error),
2445
+ appendTraceOutput(getStateTrace(index), replay.lines),
2446
+ { isNextState: true, ...replay.result },
2447
+ );
2448
+ };
2449
+ const expandState = (index: number, liveSuccessors: LiveSuccessor[]) => {
1315
2450
  const state = states[index];
1316
- const liveSuccessors: LiveSuccessor[] = [];
1317
- const successorCount = forEachSuccessor(
1318
- next,
1319
- state,
1320
- environment,
1321
- (successor) => {
1322
- try {
1323
- outcome.result = visitSuccessor(index, successor, liveSuccessors);
1324
- } catch (error) {
1325
- outcome.result = toFailure(error, getTrace(index, successor));
2451
+ const source = stateWriter && getGraphState(state, depths[index]);
2452
+ const successorCount = forEachActionSuccessor(state, (successor, action) => {
2453
+ try {
2454
+ outcome.result = visitSuccessor(index, successor, liveSuccessors, source, action);
2455
+ } catch (error) {
2456
+ if (isStackOverflow(error)) {
2457
+ outcome.result = reportNextStateOverflow(index);
2458
+ return true;
1326
2459
  }
1327
- return outcome.result !== undefined;
1328
- },
1329
- spec.scope,
1330
- );
2460
+ // TLC 1.7.4 reports the wrapped error without the trace, except for a failed property,
2461
+ // which it reports with the trace before it rethrows. The error stops its worker before it
2462
+ // adds the state to the behavior graph.
2463
+ const replay = is174
2464
+ ? getOutput(() => replayNext(index))
2465
+ : replayFailedNext(index, liveSuccessors);
2466
+ if (is174 && error instanceof TlaEvaluationError && !headedErrors.has(error)) {
2467
+ outcome.result = toFailure(
2468
+ new TlaEvaluationError(`${getWrappedException(error)}${error.message}`, error),
2469
+ appendTraceOutput({ trace: [] }, replay.lines),
2470
+ { isNextState: true, ...replay.result },
2471
+ );
2472
+ return true;
2473
+ }
2474
+ // A successor TLC can't fingerprint fails again as TLC prints it in the trace, which TLC
2475
+ // reports as an exception it didn't expect.
2476
+ const isTraceFailed = getFingerprintState(successor.state).some(
2477
+ (value) => getFingerprintError(value) !== undefined,
2478
+ );
2479
+ const traceFailure =
2480
+ isTraceFailed && error instanceof TlaEvaluationError
2481
+ ? getFailureMessage(
2482
+ isEvalException(error)
2483
+ ? new TlaEvaluationError(`${UNEXPECTED_EVAL_EXCEPTION}${error.message}`)
2484
+ : error,
2485
+ true,
2486
+ )
2487
+ : undefined;
2488
+ outcome.result = toFailure(
2489
+ error,
2490
+ appendTraceOutput(
2491
+ traceFailure ? getStateTrace(index) : getFailedTrace(index, successor),
2492
+ replay.lines,
2493
+ ),
2494
+ { isNextState: true, ...replay.result, traceFailure },
2495
+ );
2496
+ }
2497
+ return outcome.result !== undefined;
2498
+ });
1331
2499
  current.isExpanding = false;
1332
- if (outcome.result) return outcome.result;
1333
- if (successorCount === 0 && config.checkDeadlock) {
1334
- return reportViolation("deadlock", { name: "deadlock", trace: getStateTrace(index) });
2500
+ const result = outcome.result;
2501
+ // TLC 1.7.4's worker stops at a violation.
2502
+ if (result?.violation && !is174) {
2503
+ const live = getOutput(() => addFailedLiveState(index, liveSuccessors));
2504
+ return {
2505
+ ...result,
2506
+ violation: appendTraceOutput(result.violation, live.lines),
2507
+ ...(live.result && { liveCallStack: live.result }),
2508
+ };
1335
2509
  }
1336
- try {
2510
+ if (result) return result;
2511
+ const addLiveState = () => {
2512
+ if (liveness && source && is174) stateWriter?.writeStuttering(source);
1337
2513
  const accepted = liveness?.addState(index, state, liveSuccessors);
1338
- current.livenessSource = -1;
1339
- if (!accepted) return undefined;
2514
+ if (!liveness || !accepted) return undefined;
2515
+ const steps = getPathSteps(accepted);
2516
+ const properties = getViolatedProperties(
2517
+ liveness,
2518
+ steps.map((step) => step.state),
2519
+ steps.length - 1,
2520
+ );
1340
2521
  return reportViolation("property-violation", {
1341
- name: accepted.name,
1342
- trace: getPathTrace(accepted.path),
2522
+ name: properties[0],
2523
+ properties,
2524
+ ...toTrace(steps, accepted, { known: 0 }),
2525
+ });
2526
+ };
2527
+ if (successorCount === 0 && config.checkDeadlock) {
2528
+ const deadlock = reportViolation("deadlock", { name: "deadlock", ...getStateTrace(index) });
2529
+ // TLC's worker still adds the deadlocked state to the behavior graph after it reports the
2530
+ // deadlock, and reports a temporal property that this violates. Then it counts the state as
2531
+ // expanded.
2532
+ const live = getOutput(() => {
2533
+ try {
2534
+ return { additional: addLiveState()?.violation };
2535
+ } catch (error) {
2536
+ if (!(error instanceof TlaEvaluationError)) throw error;
2537
+ return { isFailed: true, callStack: getLiveCallStack(index, liveSuccessors) };
2538
+ }
1343
2539
  });
2540
+ const reported = deadlock.violation
2541
+ ? { ...deadlock, violation: appendTraceOutput(deadlock.violation, live.lines) }
2542
+ : deadlock;
2543
+ // An error in adding the state stops TLC 1.7.4's worker before it counts the state.
2544
+ const counted = withOutDegrees(
2545
+ reported,
2546
+ live.result.isFailed ? getFailureOutDegrees() : getPartialOutDegrees(),
2547
+ );
2548
+ if (live.result.additional)
2549
+ return { ...counted, additionalViolation: live.result.additional };
2550
+ return live.result.callStack ? { ...counted, liveCallStack: live.result.callStack } : counted;
2551
+ }
2552
+ try {
2553
+ return addLiveState();
1344
2554
  } catch (error) {
1345
- return toFailure(error, getStateTrace(index), undefined, getPartialOutDegrees());
2555
+ // TLC 1.7.4's worker reports an error in adding a state to the behavior graph as an exception
2556
+ // it didn't expect, without the trace or a call stack, and exits as for any general error.
2557
+ if (is174 && error instanceof TlaEvaluationError) {
2558
+ const unexpected = new TlaEvaluationError(
2559
+ `${isEvalException(error) ? UNEXPECTED_EVAL_EXCEPTION : UNEXPECTED_EXCEPTION}${error.message}`,
2560
+ );
2561
+ return toFailure(
2562
+ setExitCode(unexpected, EXIT_STATUS.error),
2563
+ { trace: [] },
2564
+ { outDegrees: getFailureOutDegrees() },
2565
+ );
2566
+ }
2567
+ // TLC's Worker#doNextCheckLiveness adds the state again to find the call stack, prints it
2568
+ // before the error, and reports the error as one in computing next states.
2569
+ const replay = getReplayFailure((tracing) =>
2570
+ liveness?.addState(index, state, liveSuccessors, tracing),
2571
+ );
2572
+ return toFailure(error, getStateTrace(index), {
2573
+ outDegrees: getFailureOutDegrees(),
2574
+ callStack: replay?.callStack.length ? replay.callStack : undefined,
2575
+ isNextState: true,
2576
+ isCallStackFirst: true,
2577
+ });
2578
+ }
2579
+ };
2580
+ // TLC's Liveness#printStutteringCounterExampleWarning.
2581
+ const getStutteringWarning = () => {
2582
+ const name = config.specification;
2583
+ const book =
2584
+ "(compare Chapter 8, page 87ff of Specifying Systems at https://lamport.azurewebsites.net/tla/book.html).";
2585
+ if (name === undefined) {
2586
+ return {
2587
+ code: MESSAGE_CODE.noSpecificationButProperty,
2588
+ text: `The stuttering counterexample above may be caused by the absence of a behavior specification (SPECIFICATION). Only INIT and NEXT have been provided, so TLC permits infinite stuttering. To rule out such counterexamples, use SPECIFICATION Spec, with Spec asserting a suitable fairness constraint ${book}`,
2589
+ };
1346
2590
  }
2591
+ const range = getDefinition(name, environment)?.location.range;
2592
+ if (spec.temporals.length > 0 || !range) return undefined;
2593
+ return {
2594
+ code: MESSAGE_CODE.noFairnessButProperty,
2595
+ text: `The stuttering counterexample above may be caused by the absence of a fairness constraint in the behavior specification ${name} defined at ${formatRange(range)}. To rule out such counterexamples, conjoin a suitable fairness constraint to ${name} ${book}`,
2596
+ };
1347
2597
  };
1348
- const reportLasso = (lasso: Lasso) => {
2598
+ // TLC names the properties and the step back into the cycle from the states it prints.
2599
+ const reportLasso = (checker: LivenessChecker, lasso: Lasso) => {
1349
2600
  const path = [...lasso.prefix, ...lasso.cycle];
1350
- const trace = getPathTrace(path, lasso.prefix.length);
1351
- const back = path[lasso.prefix.length];
2601
+ const loopStart = lasso.prefix.length;
2602
+ const steps = getPathSteps(path, loopStart);
2603
+ const trace = toTrace(steps, path, { loopStart, known: 0 }).trace;
2604
+ const properties = getViolatedProperties(
2605
+ checker,
2606
+ steps.map((step) => step.state),
2607
+ loopStart,
2608
+ );
2609
+ const back = path[loopStart];
1352
2610
  const last = path[path.length - 1];
1353
- const loopLabel =
1354
- back === last ? undefined : withoutOutput(() => getLabel(last, states[last], states[back]));
2611
+ const lastState = steps[steps.length - 1].state;
2612
+ const loop =
2613
+ back === last
2614
+ ? { result: undefined, lines: [] }
2615
+ : getOutput(() => findStepAction(last, lastState, states[back], false));
2616
+ const isStutteringWarned = back === last && lasso.isCycleConstrained;
1355
2617
  return reportViolation(
1356
2618
  "liveness-violation",
1357
- { name: lasso.name, trace, loopStart: lasso.prefix.length, loopLabel },
2619
+ {
2620
+ name: properties[0],
2621
+ properties,
2622
+ trace,
2623
+ traceOutput: loop.lines,
2624
+ loopStart,
2625
+ loopLabel: loop.result && getActionLabel(loop.result, options.version),
2626
+ warning: isStutteringWarned ? getStutteringWarning() : undefined,
2627
+ },
1358
2628
  () =>
1359
2629
  back === last
1360
- ? trace[trace.length - 1].action
1361
- : getTraceSuccessors(states[last]).find((successor) =>
1362
- isSameState(successor.state, states[back]),
1363
- )?.action,
2630
+ ? getStepAction(trace[trace.length - 1])
2631
+ : loop.result
2632
+ ? toActionValue(loop.result)
2633
+ : createActionRecord(findSuccessorWithFingerprint(lastState, back)?.action),
1364
2634
  );
1365
2635
  };
1366
2636
  const isPeriodic = liveness !== undefined && options.livenessCheck !== "final";
@@ -1368,44 +2638,78 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1368
2638
  const periodic = { at: startedAt + PERIODIC_START, size: 1, time: 0 };
1369
2639
  const findPeriodicViolation = (expanded: number) => {
1370
2640
  const now = performance.now();
1371
- periodic.at = now + PROGRESS_INTERVAL;
1372
2641
  const isGrown = (expanded - periodic.size) / periodic.size > LIVENESS_GROWTH;
1373
2642
  if (!isGrown || periodic.time > (now - startedAt) * LIVENESS_RATIO) return undefined;
1374
2643
  periodic.size = expanded;
1375
- const lasso = liveness?.findViolation();
1376
- current.livenessSource = -1;
2644
+ if (!liveness) return undefined;
2645
+ options.onProgress?.({
2646
+ kind: "liveness-started",
2647
+ branches: liveness.branches,
2648
+ isComplete: false,
2649
+ states: expanded,
2650
+ statistics: createResult("success"),
2651
+ });
2652
+ const lasso = liveness.findViolation();
2653
+ if (!lasso) options.onProgress?.({ kind: "liveness-finished" });
1377
2654
  periodic.time += performance.now() - now;
1378
2655
  return lasso;
1379
2656
  };
1380
- setNextStatePhase(true);
1381
2657
  for (let index = 0; index < states.length && !runtime.isStopped; index++) {
1382
2658
  current.index = index;
1383
2659
  current.candidate = undefined;
1384
2660
  runtime.queueSize = states.length - index - 1;
1385
2661
  current.isExpanding = true;
2662
+ const liveSuccessors: LiveSuccessor[] = [];
1386
2663
  try {
1387
- outcome.result = expandState(index);
2664
+ outcome.result = expandState(index, liveSuccessors);
1388
2665
  } catch (error) {
1389
- outcome.result = toFailure(error, getStateTrace(index));
2666
+ outcome.result =
2667
+ error instanceof TlaIncompleteSuccessorError
2668
+ ? reportIncompleteSuccessor(index, error)
2669
+ : reportNextStateFailure(error, index, liveSuccessors);
1390
2670
  }
1391
2671
  if (outcome.result) return outcome.result;
1392
2672
  outDegrees[getOutDegreeBucket()]++;
1393
2673
  expansion.newStates = 0;
1394
- if (isPeriodic && performance.now() >= periodic.at) {
1395
- const lasso = findPeriodicViolation(index + 1);
1396
- if (lasso) return reportLasso(lasso);
2674
+ // TLC's AbstractChecker#runTLC checks the liveness properties on the state graph so far, then
2675
+ // reports how far the search got.
2676
+ if ((isPeriodic || options.onProgress) && performance.now() >= periodic.at) {
2677
+ periodic.at = performance.now() + PROGRESS_INTERVAL;
2678
+ const lasso = isPeriodic ? findPeriodicViolation(index + 1) : undefined;
2679
+ if (liveness && lasso) return reportLasso(liveness, lasso);
2680
+ options.onProgress?.({ kind: "progress", statistics: createResult("success") });
1397
2681
  }
1398
2682
  }
1399
2683
 
1400
2684
  current.index = -1;
1401
2685
  current.candidate = undefined;
2686
+ if (liveness) {
2687
+ options.onProgress?.({
2688
+ kind: "liveness-started",
2689
+ branches: liveness.branches,
2690
+ isComplete: true,
2691
+ states: runtime.distinctStates,
2692
+ statistics: createResult("success"),
2693
+ });
2694
+ }
1402
2695
  const lasso = liveness?.findViolation();
1403
- current.livenessSource = -1;
1404
- if (lasso) return reportLasso(lasso);
2696
+ if (liveness && lasso) return reportLasso(liveness, lasso);
1405
2697
 
1406
- const postconditionViolation = search.findPostconditionViolation();
1407
- if (postconditionViolation) {
1408
- return createResult("postcondition-violation", { ...postconditionViolation, trace: [] });
2698
+ // TLC finishes the check of the temporal properties before it checks the postconditions.
2699
+ if (liveness) options.onProgress?.({ kind: "liveness-finished" });
2700
+ try {
2701
+ const postcondition = search.findPostconditionViolation();
2702
+ if (postcondition) {
2703
+ return createResult("postcondition-violation", {
2704
+ name: postcondition.name,
2705
+ message: postcondition.message,
2706
+ counts: postcondition.counts,
2707
+ trace: [],
2708
+ postcondition,
2709
+ });
2710
+ }
2711
+ } catch (error) {
2712
+ return toFailure(error, { trace: [] });
1409
2713
  }
1410
2714
  return createSuccess();
1411
2715
  };