tla-ts 0.0.3-dev.6a30eee → 0.0.3-dev.6ac5593

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 (55) hide show
  1. package/README.md +5 -1
  2. package/dist/index.cjs +1 -1
  3. package/dist/index.d.cts +70 -22
  4. package/dist/index.d.ts +70 -22
  5. package/dist/index.js +1 -1
  6. package/dist/parallel-worker.cjs +1 -1
  7. package/dist/parallel-worker.js +2 -2
  8. package/dist/parallel.cjs +1 -1
  9. package/dist/parallel.js +2 -2
  10. package/dist/run-cli.cjs +20 -18
  11. package/dist/run-cli.js +22 -20
  12. package/dist/transfer.cjs +41 -15
  13. package/dist/transfer.js +41 -15
  14. package/package.json +1 -1
  15. package/src/ast.ts +121 -4
  16. package/src/builtins.ts +9 -3
  17. package/src/check.ts +480 -106
  18. package/src/cli-options.ts +11 -5
  19. package/src/codegen.ts +15 -22
  20. package/src/config.ts +224 -170
  21. package/src/dependencies.ts +2 -2
  22. package/src/environment.ts +410 -130
  23. package/src/errors.ts +104 -3
  24. package/src/evaluate.ts +402 -182
  25. package/src/exit-codes.ts +21 -14
  26. package/src/fingerprints.ts +2 -1
  27. package/src/instances.ts +17 -16
  28. package/src/levels.ts +185 -44
  29. package/src/live-check.ts +132 -70
  30. package/src/liveness.ts +118 -24
  31. package/src/parallel-worker.ts +2 -2
  32. package/src/parallel.ts +5 -2
  33. package/src/parser.ts +172 -53
  34. package/src/resolve.ts +1378 -420
  35. package/src/run-cli.ts +106 -18
  36. package/src/runtime.ts +2 -0
  37. package/src/sany-lexer.ts +615 -0
  38. package/src/sany-parse-error.ts +3143 -0
  39. package/src/spec-description.ts +19 -8
  40. package/src/standard-modules.ts +54 -45
  41. package/src/standard-ranges.ts +116 -0
  42. package/src/state-graph.ts +157 -0
  43. package/src/subexpressions.ts +231 -171
  44. package/src/substitution-levels.ts +38 -17
  45. package/src/successors.ts +177 -37
  46. package/src/symmetry.ts +109 -41
  47. package/src/tableau.ts +51 -24
  48. package/src/tlc-ext.ts +29 -12
  49. package/src/tlc-module.ts +14 -33
  50. package/src/tlc-modules.ts +4 -0
  51. package/src/tlc-order.ts +8 -4
  52. package/src/tlc-random.ts +9 -6
  53. package/src/tlc-summary.ts +20 -5
  54. package/src/value-sources.ts +29 -0
  55. package/src/values.ts +242 -61
package/src/check.ts CHANGED
@@ -1,25 +1,34 @@
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
12
  import {
6
13
  getErrorExitCode,
14
+ isStackOverflow,
15
+ formatRange,
16
+ STACK_OVERFLOW,
7
17
  TlaConfigError,
8
18
  TlaEvaluationError,
19
+ TlaIllegalStateError,
20
+ TlaIncompleteStateError,
9
21
  TlaModuleError,
10
22
  UNEXPECTED_EXCEPTION,
11
23
  } from "./errors";
12
- import { EXIT_STATUS, setExitCode, setNextStatePhase, withLivenessExitCode } from "./exit-codes";
24
+ import { EXIT_STATUS, setExitCode, withLivenessExitCode } from "./exit-codes";
13
25
  import {
14
26
  describeRange,
15
27
  evaluate,
16
28
  expectBoolean,
17
- formatRange,
18
- getChildren,
19
29
  getDefinition,
20
30
  isConstantLevel,
21
31
  isImpure,
22
- isLocallyResolved,
23
32
  type Context,
24
33
  type Environment,
25
34
  type Scope,
@@ -27,6 +36,7 @@ import {
27
36
  import {
28
37
  createLivenessChecker,
29
38
  type Lasso,
39
+ type LiveGraph,
30
40
  type LivenessChecker,
31
41
  type LiveSuccessor,
32
42
  } from "./live-check";
@@ -42,19 +52,30 @@ import {
42
52
  } from "./successors";
43
53
  import {
44
54
  getActionLabel,
55
+ getActionSignature,
45
56
  getNextActions,
46
57
  getSpecificationValue,
47
58
  type SpecAction,
48
59
  } from "./spec-description";
60
+ import {
61
+ createStateWriter,
62
+ type GraphState,
63
+ type StateDump,
64
+ type StateWriter,
65
+ } from "./state-graph";
49
66
  import { getRepresentative, getSymmetryGroup } from "./symmetry";
50
- import { getTlcStringOrder, getTlcVariableOrder } from "./tlc-order";
67
+ import { getTlcStringOrder, getTlcDeclarationOrder } from "./tlc-order";
51
68
  import { createTlcFingerprinter, getTlcFingerprint } from "./tlc-random";
52
69
  import { createCanonicalizer } from "./canonical";
53
70
  import { getPossibleCounts, type CheckerRuntime } from "./runtime";
54
71
  import { createCounterExample } from "./tlc-ext";
72
+ import { getFingerprintTrace, valueSources } from "./value-sources";
55
73
  import { getFingerprintDistance, OUT_DEGREE_BUCKETS } from "./tlc-summary";
56
74
  import {
75
+ assertFingerprintable,
57
76
  combineHash,
77
+ createModelValue,
78
+ formatState,
58
79
  formatValue,
59
80
  getValueHash,
60
81
  isFunctionValue,
@@ -78,6 +99,8 @@ export interface CheckOptions {
78
99
  workers?: number;
79
100
  // TLC's -lncheck: "final" checks liveness only on the complete state graph.
80
101
  livenessCheck?: "default" | "final";
102
+ // TLC's -dump: writes the reachable states, or with `dot` the state graph, through writeFile.
103
+ dump?: StateDump;
81
104
  }
82
105
 
83
106
  export type CheckStatus =
@@ -121,6 +144,25 @@ export interface EvaluationFailure {
121
144
  trace: TraceStep[];
122
145
  initialState: Record<string, Value> | undefined;
123
146
  exitCode: number;
147
+ replay?: Replay;
148
+ isWithoutStatistics?: boolean;
149
+ }
150
+
151
+ // TLC replays a failed step to print the expressions it was evaluating when the replay failed.
152
+ export interface Replay {
153
+ output: string[];
154
+ callStack: string[] | undefined;
155
+ fingerprint?: Fingerprint;
156
+ // The worker that fails to check liveness replays the step at once, so TLC prints the stack
157
+ // before the error, and only when it holds a frame.
158
+ isBeforeError?: boolean;
159
+ }
160
+
161
+ // TLC reports an error from a method of a value that has a source as one it was unable to
162
+ // fingerprint. With an empty stack, it lists the sources of the values instead.
163
+ export interface Fingerprint {
164
+ sources: string[];
165
+ reason: string;
124
166
  }
125
167
 
126
168
  export interface CheckResult {
@@ -232,7 +274,7 @@ const getConstantValue = (name: string, definition: Definition, environment: Env
232
274
  try {
233
275
  return evaluate(createIdentifier(name), getContext(environment, undefined, undefined));
234
276
  } catch (error) {
235
- if (error instanceof TlaEvaluationError) return undefined;
277
+ if (error instanceof TlaEvaluationError || isStackOverflow(error)) return undefined;
236
278
  throw error;
237
279
  }
238
280
  };
@@ -261,8 +303,11 @@ const getInvariants = (names: string[], environment: Environment) => {
261
303
  levels.params.size === 0
262
304
  ? ""
263
305
  : "\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.";
264
- throw new TlaConfigError(
265
- `The invariant ${name} is not a state predicate (one with no primes or temporal operators).${note}`,
306
+ throw setExitCode(
307
+ new TlaConfigError(
308
+ `The invariant ${name} is not a state predicate (one with no primes or temporal operators).${note}`,
309
+ ),
310
+ EXIT_STATUS.safetyEvaluationFailure,
266
311
  );
267
312
  }
268
313
  return [{ name, expression: createIdentifier(name), scope: undefined }];
@@ -360,8 +405,11 @@ const getSpecification = (config: ModelConfig, environment: Environment): Specif
360
405
  conjunct.kind === "Always" &&
361
406
  getLevel(conjunct.expression, item.scope, environment) < ACTION_LEVEL
362
407
  ) {
363
- throw new TlaConfigError(
364
- `TLC cannot handle []P in the specification ${config.specification} when P is a state predicate`,
408
+ throw setExitCode(
409
+ new TlaConfigError(
410
+ `TLC cannot handle the temporal formula ${describeRange(conjunct.expression)}`,
411
+ ),
412
+ EXIT_STATUS.error,
365
413
  );
366
414
  }
367
415
  const level = getLevel(conjunct, item.scope, environment);
@@ -431,12 +479,12 @@ const getProperties = (config: ModelConfig, environment: Environment): Propertie
431
479
  config.properties.forEach((name) => {
432
480
  const definition = getConfigPredicate("property", name, environment);
433
481
  if (!definition) return;
434
- expandTemporal(definition.body, undefined, environment, true).forEach((item) => {
482
+ expandTemporal(definition.body, undefined, environment, true, name).forEach((item) => {
435
483
  const conjunct = item.expression;
436
484
  if (isConstantTrue(item, environment, "property")) return;
437
485
  if (conjunct.kind === "Always" && conjunct.expression.kind === "BoxAction") {
438
486
  properties.actionProperties.push({
439
- name,
487
+ name: item.name,
440
488
  box: conjunct.expression,
441
489
  action: conjunct.expression.action,
442
490
  subscript: conjunct.expression.subscript,
@@ -448,12 +496,22 @@ const getProperties = (config: ModelConfig, environment: Environment): Propertie
448
496
  conjunct.kind === "Always" &&
449
497
  getLevel(conjunct.expression, item.scope, environment) <= 1
450
498
  ) {
451
- properties.invariants.push({ name, expression: conjunct.expression, scope: item.scope });
499
+ // TLC names the invariant []P after P when P is an operator name.
500
+ const expression = conjunct.expression;
501
+ properties.invariants.push({
502
+ name: expression.kind === "Identifier" ? expression.name : item.name,
503
+ expression,
504
+ scope: item.scope,
505
+ });
452
506
  return;
453
507
  }
454
508
  const level = getLevel(conjunct, item.scope, environment);
455
509
  if (level < ACTION_LEVEL) {
456
- properties.initialPredicates.push({ name, expression: conjunct, scope: item.scope });
510
+ properties.initialPredicates.push({
511
+ name: item.name,
512
+ expression: conjunct,
513
+ scope: item.scope,
514
+ });
457
515
  return;
458
516
  }
459
517
  if (level === ACTION_LEVEL) {
@@ -513,7 +571,9 @@ const getMembership = (
513
571
  const getStateChecks = (named: NamedExpression[], environment: Environment): StateCheck[] =>
514
572
  named.flatMap((item) =>
515
573
  getConjuncts(item.expression, environment).map((expression) => {
516
- const variables = getReadVariables(expression, environment);
574
+ // A LET or an argument in the scope can read variables the expression doesn't name.
575
+ const variables =
576
+ item.scope === undefined ? getReadVariables(expression, environment) : undefined;
517
577
  return {
518
578
  name: item.name,
519
579
  expression,
@@ -692,7 +752,7 @@ export const createSearch = (
692
752
  const possible = getPossiblePredicates(config.possible, environment);
693
753
  if (environment.variables.length === 0) return undefined;
694
754
  const symmetryGroup =
695
- config.symmetry === undefined ? [] : getSymmetryGroup(config.symmetry, environment);
755
+ config.symmetry === undefined ? undefined : getSymmetryGroup(config.symmetry, environment);
696
756
  if (config.view !== undefined) getConfigOperator("view function", config.view, environment);
697
757
  const view =
698
758
  config.view === undefined
@@ -724,14 +784,12 @@ export const createSearch = (
724
784
  .sort((left, right) => getTlcPosition(left) - getTlcPosition(right));
725
785
  return tlcOrder.indices;
726
786
  };
727
- // A representative in TLC's variable order is the one whose fingerprint TLC reports.
728
- const order = symmetryGroup.length > 0 ? getTlcOrder() : undefined;
729
787
  const getViewValue = (expression: Expression, state: Value[]) =>
730
788
  evaluate(expression, getContext(environment, state, undefined));
731
789
  const getTlcStateFingerprint = (state: Value[]) => {
732
790
  const indices = getTlcOrder();
733
791
  const representative =
734
- symmetryGroup.length === 0 ? state : getRepresentative(state, symmetryGroup, indices);
792
+ symmetryGroup === undefined ? state : getRepresentative(state, symmetryGroup, indices);
735
793
  return getTlcFingerprint(
736
794
  view === undefined
737
795
  ? indices.map((index) => representative[index])
@@ -754,22 +812,27 @@ export const createSearch = (
754
812
  return {
755
813
  properties,
756
814
  spec,
757
- isSymmetric: symmetryGroup.length > 0,
815
+ isSymmetric: symmetryGroup !== undefined,
758
816
  getTlcOrder,
759
817
  getStoredFingerprints: (states, fingerprintStates) => {
760
818
  if (view !== undefined || isFingerprintedLikeTlc) {
761
819
  return BigInt64Array.from(states, getTlcStateFingerprint);
762
820
  }
763
- const indices = getTlcOrder();
764
- const getFingerprint = createTlcFingerprinter();
765
- return BigInt64Array.from(fingerprintStates, (state) =>
766
- getFingerprint(indices.map((index) => state[index])),
821
+ const fingerprints = new BigInt64Array(fingerprintStates.length);
822
+ const fingerprint = createTlcFingerprinter(
823
+ getTlcOrder(),
824
+ new Int32Array(fingerprints.buffer),
767
825
  );
826
+ fingerprintStates.forEach(fingerprint);
827
+ return fingerprints;
768
828
  },
769
829
  getFingerprintState: (state) => {
770
830
  if (isFingerprintedLikeTlc) return [String(getTlcStateFingerprint(state))];
831
+ // A representative in TLC's variable order is the one whose fingerprint TLC reports.
771
832
  const representative =
772
- symmetryGroup.length === 0 ? state : getRepresentative(state, symmetryGroup, order);
833
+ symmetryGroup === undefined
834
+ ? state
835
+ : getRepresentative(state, symmetryGroup, getTlcOrder());
773
836
  return view === undefined ? representative : [getViewValue(view.expression, representative)];
774
837
  },
775
838
  findViolatedInvariant: (state, parent) =>
@@ -796,11 +859,17 @@ export const createSearch = (
796
859
  }
797
860
  }),
798
861
  satisfiesConstraints: (state, parent) =>
799
- constraints.every(
800
- (constraint) =>
801
- isUnchangedFor(constraint, state, parent) ||
802
- holdsLikeTlc(constraint.expression, getContext(environment, state, undefined)),
803
- ),
862
+ constraints.every((constraint) => {
863
+ try {
864
+ return (
865
+ isUnchangedFor(constraint, state, parent) ||
866
+ holdsLikeTlc(constraint.expression, getContext(environment, state, undefined))
867
+ );
868
+ } catch (error) {
869
+ // TLC reports a failing constraint on a successor like a failure of the next-state relation.
870
+ throw parent ? toNextStateError(error) : error;
871
+ }
872
+ }),
804
873
  findFailedInitialPredicate: (state) =>
805
874
  properties.initialPredicates.find(
806
875
  (predicate) =>
@@ -826,17 +895,20 @@ export const createSearch = (
826
895
  )
827
896
  );
828
897
  } catch (error) {
829
- throw withHeadline(error, `Evaluating action property ${property.name} failed.`);
898
+ throw withHeadline(
899
+ withNextStateExitCode(error),
900
+ `Evaluating action property ${property.name} failed.`,
901
+ );
830
902
  }
831
903
  }),
832
904
  satisfiesActionConstraints: (state, next) =>
833
- actionConstraints.every((constraint) =>
834
- holdsLikeTlc(
835
- constraint.expression,
836
- getContext(environment, state, next),
837
- (expression) => `${UNEXPECTED_EXCEPTION}${getExpectedBoolean(expression, environment)}`,
838
- ),
839
- ),
905
+ actionConstraints.every((constraint) => {
906
+ try {
907
+ return holdsLikeTlc(constraint.expression, getContext(environment, state, next));
908
+ } catch (error) {
909
+ throw toNextStateError(error);
910
+ }
911
+ }),
840
912
  trackStatePossible:
841
913
  statePossible.length === 0
842
914
  ? ignorePossible
@@ -862,6 +934,64 @@ export const createSearch = (
862
934
  };
863
935
  };
864
936
 
937
+ // TLC exits with the code of a standard module's failure only when the failure escapes the
938
+ // computation of next states. In every other phase, the phase decides the code.
939
+ const withNextStateExitCode = (error: unknown) =>
940
+ error instanceof TlaModuleError ? setExitCode(error, error.exitCode) : error;
941
+
942
+ // TLC reports a failure of the next-state relation, or of the liveness check of a step, as an
943
+ // unexpected exception, unless a standard module raised it as an EvalException.
944
+ const toNextStateError = (error: unknown) =>
945
+ error instanceof TlaEvaluationError &&
946
+ !(error instanceof TlaModuleError) &&
947
+ !(error instanceof TlaIncompleteStateError)
948
+ ? setExitCode(
949
+ new TlaEvaluationError(`${UNEXPECTED_EXCEPTION}${error.message}`, error),
950
+ getErrorExitCode(error),
951
+ )
952
+ : withNextStateExitCode(error);
953
+
954
+ const isRepeated = (frame: string, index: number, frames: string[]) =>
955
+ index > 0 && frames[index - 1] === frame;
956
+
957
+ // FingerprintException#getTrace numbers the sources from the outermost value and lists the innermost
958
+ // first.
959
+ const getSourceTrace = (sources: Expression[]) =>
960
+ sources
961
+ .flatMap((source) => (source.location.range ? [formatRange(source.location.range)] : []))
962
+ .filter((source, index, all) => !isRepeated(source, index, all))
963
+ .map((source, index) => `${index}) ${source}`)
964
+ .reverse();
965
+
966
+ // TLC keeps the stack only when an evaluation fails, and prints each expression on it once, however
967
+ // many times in a row it pushed it.
968
+ const getReplayedCallStack = (
969
+ replay: () => void,
970
+ trace: Expression[],
971
+ ): Pick<Replay, "callStack" | "fingerprint"> => {
972
+ try {
973
+ replay();
974
+ return { callStack: undefined };
975
+ } catch (error) {
976
+ if (!(error instanceof TlaEvaluationError)) return { callStack: [] };
977
+ const callStack = trace
978
+ .flatMap((expression) => {
979
+ const range = expression.location.range;
980
+ return range
981
+ ? [
982
+ `Line ${range.start.line}, column ${range.start.column} to line ${range.end.line}, column ${range.end.column} in ${range.module}`,
983
+ ]
984
+ : [];
985
+ })
986
+ .filter((frame, index, frames) => !isRepeated(frame, index, frames));
987
+ const sources = getFingerprintTrace(error);
988
+ return {
989
+ callStack,
990
+ fingerprint: sources && { sources: getSourceTrace(sources), reason: error.message },
991
+ };
992
+ }
993
+ };
994
+
865
995
  const withHeadline = (error: unknown, headline: string) =>
866
996
  error instanceof TlaEvaluationError
867
997
  ? setExitCode(
@@ -870,15 +1000,30 @@ const withHeadline = (error: unknown, headline: string) =>
870
1000
  )
871
1001
  : error;
872
1002
 
1003
+ // TLC finishes the -dump file whether or not the search finds a violation.
873
1004
  export const checkSequentially = (options: CheckOptions): CheckResult => {
874
- setNextStatePhase(false);
1005
+ const stateWriter = options.dump && createStateWriter(options.dump, options.writeFile);
1006
+ try {
1007
+ return searchStates(options, stateWriter);
1008
+ } catch (error) {
1009
+ // TLC reports a stack overflow outside the search as a failure of its own, with exit code 255.
1010
+ throw isStackOverflow(error)
1011
+ ? setExitCode(new TlaEvaluationError(STACK_OVERFLOW), EXIT_STATUS.error)
1012
+ : error;
1013
+ } finally {
1014
+ stateWriter?.close();
1015
+ }
1016
+ };
1017
+
1018
+ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefined): CheckResult => {
875
1019
  const config = typeof options.config === "string" ? parseConfig(options.config) : options.config;
876
1020
  const onPrint = options.onPrint ?? console.log;
877
1021
  // TLC prints again while it rebuilds a trace, between the states it prints. Printing those lines
878
1022
  // before the trace would misplace them, so rebuilding a trace prints nothing.
879
- const output = { isMuted: false };
1023
+ const output = { isMuted: false, replayed: undefined as string[] | undefined };
880
1024
  const print = (text: string) => {
881
- if (!output.isMuted) onPrint(text);
1025
+ if (output.replayed) output.replayed.push(text);
1026
+ else if (!output.isMuted) onPrint(text);
882
1027
  };
883
1028
  const withoutOutput = <Result>(rebuild: () => Result) => {
884
1029
  output.isMuted = true;
@@ -940,9 +1085,9 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
940
1085
  ),
941
1086
  });
942
1087
 
943
- const search = createSearch(config, environment, () =>
944
- getTlcVariableOrder(options.source, options.loadModule),
945
- );
1088
+ const getVariableOrder = () =>
1089
+ getTlcDeclarationOrder(options.source, options.loadModule, "variable");
1090
+ const search = createSearch(config, environment, getVariableOrder);
946
1091
  const assumptionViolation = findAssumptionViolation(specification.assumptions, environment);
947
1092
  if (assumptionViolation) return createResult("assumption-violation", assumptionViolation);
948
1093
  if (!search) return createSuccess();
@@ -966,37 +1111,114 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
966
1111
  const spec = search.spec;
967
1112
  const getFingerprintState = search.getFingerprintState;
968
1113
  const nextActions = { value: undefined as SpecAction[] | undefined };
1114
+ const replayFailure = (
1115
+ result: CheckResult,
1116
+ replay: (tracedSearch: Search, traced: Environment) => void,
1117
+ isBeforeError = false,
1118
+ ): CheckResult => {
1119
+ if (!result.failure) return result;
1120
+ const trace: Expression[] = [];
1121
+ const traced: Environment = { ...environment, evaluators: new WeakMap(), trace };
1122
+ const tracedSearch = createSearch(config, traced, getVariableOrder);
1123
+ if (!tracedSearch) return result;
1124
+ const replayed: string[] = [];
1125
+ output.replayed = replayed;
1126
+ valueSources.current = new WeakMap();
1127
+ const replayedStack = getReplayedCallStack(() => replay(tracedSearch, traced), trace);
1128
+ valueSources.current = undefined;
1129
+ output.replayed = undefined;
1130
+ return {
1131
+ ...result,
1132
+ failure: { ...result.failure, replay: { output: replayed, ...replayedStack, isBeforeError } },
1133
+ };
1134
+ };
1135
+ // TLC fingerprints a state outside CallStackTool, so a failure of a value with a source leaves
1136
+ // the stack empty. Any other failure keeps the stack of the initial predicate.
1137
+ const fingerprintReplayed = (state: Value[], traced: Environment) => {
1138
+ try {
1139
+ getStateHash(getFingerprintState(state));
1140
+ } catch (error) {
1141
+ if (traced.trace && getFingerprintTrace(error)) traced.trace.length = 0;
1142
+ throw error;
1143
+ }
1144
+ };
1145
+ // TLC checks every initial state again, as when it first generated them.
1146
+ const replayInitialStates = (result: CheckResult) =>
1147
+ replayFailure(result, (tracedSearch, traced) => {
1148
+ if (spec.init === undefined) return;
1149
+ forEachInitialState(
1150
+ spec.init,
1151
+ traced,
1152
+ (state) => {
1153
+ if (tracedSearch.satisfiesConstraints(state)) fingerprintReplayed(state, traced);
1154
+ return (
1155
+ tracedSearch.findViolatedInvariant(state) !== undefined ||
1156
+ tracedSearch.findFailedInitialPredicate(state) !== undefined
1157
+ );
1158
+ },
1159
+ spec.scope,
1160
+ );
1161
+ });
1162
+ // TLC rebuilds the behavior up to the state it expanded before it replays the step.
1163
+ const rebuildBehavior = (index: number): void => {
1164
+ const parent = parents[index];
1165
+ if (parent === -1) {
1166
+ getSpecInitialStates();
1167
+ return;
1168
+ }
1169
+ rebuildBehavior(parent);
1170
+ getLabel(parent, states[parent], states[index]);
1171
+ };
1172
+ // TLC generates the successors of each action before it checks them. It checks the invariants
1173
+ // only of a successor outside the model, since it has seen the others.
1174
+ const replaySuccessors = (result: CheckResult, index: number) =>
1175
+ replayFailure(result, (tracedSearch, traced) => {
1176
+ rebuildBehavior(index);
1177
+ const state = states[index];
1178
+ nextActions.value ??= getNextActions(config, environment, specification.instanceActions);
1179
+ nextActions.value.find((action) =>
1180
+ getSuccessors(action.expression, state, traced, action.scope).some((successor) => {
1181
+ const isInModel =
1182
+ tracedSearch.satisfiesConstraints(successor.state) &&
1183
+ tracedSearch.satisfiesActionConstraints(state, successor.state);
1184
+ if (isInModel) fingerprintReplayed(successor.state, traced);
1185
+ return (
1186
+ (!isInModel && tracedSearch.findViolatedInvariant(successor.state) !== undefined) ||
1187
+ tracedSearch.findViolatedActionProperty(state, successor.state) !== undefined
1188
+ );
1189
+ }),
1190
+ );
1191
+ });
969
1192
  const isReducing = config.view !== undefined || config.symmetry !== undefined;
970
1193
  const tlcFingerprints: number[] = [];
1194
+ const liveGraph: LiveGraph = {
1195
+ getFingerprint: (index) =>
1196
+ (tlcFingerprints[index] ??= Number(BigInt.asIntN(32, runtime.getFingerprint(states[index])))),
1197
+ getSuccessors: (state) => {
1198
+ const successors: LiveSuccessor[] = [];
1199
+ if (spec.next === undefined) return successors;
1200
+ forEachSuccessor(
1201
+ spec.next,
1202
+ state,
1203
+ environment,
1204
+ (successor) => {
1205
+ canonicalizeState(successor.state);
1206
+ const isInModel =
1207
+ search.satisfiesConstraints(successor.state, state) &&
1208
+ search.satisfiesActionConstraints(state, successor.state);
1209
+ if (!isInModel) return false;
1210
+ const fingerprintState = getFingerprintState(successor.state);
1211
+ const index = findStateIndex(getStateHash(fingerprintState), fingerprintState);
1212
+ successors.push({ index, state: successor.state });
1213
+ return false;
1214
+ },
1215
+ spec.scope,
1216
+ );
1217
+ return successors;
1218
+ },
1219
+ };
971
1220
  const liveness = withLivenessExitCode(() =>
972
- createLivenessChecker(search.properties.liveness, spec.temporals, environment, {
973
- getFingerprint: (index) =>
974
- (tlcFingerprints[index] ??= Number(
975
- BigInt.asIntN(32, runtime.getFingerprint(states[index])),
976
- )),
977
- getSuccessors: (state) => {
978
- const successors: LiveSuccessor[] = [];
979
- if (spec.next === undefined) return successors;
980
- forEachSuccessor(
981
- spec.next,
982
- state,
983
- environment,
984
- (successor) => {
985
- canonicalizeState(successor.state);
986
- const isInModel =
987
- search.satisfiesConstraints(successor.state, state) &&
988
- search.satisfiesActionConstraints(state, successor.state);
989
- if (!isInModel) return false;
990
- const fingerprintState = getFingerprintState(successor.state);
991
- const index = findStateIndex(getStateHash(fingerprintState), fingerprintState);
992
- successors.push({ index, state: successor.state });
993
- return false;
994
- },
995
- spec.scope,
996
- );
997
- return successors;
998
- },
999
- }),
1221
+ createLivenessChecker(search.properties.liveness, spec.temporals, environment, liveGraph),
1000
1222
  );
1001
1223
  const isCanonicalizedFirst = search.isSymmetric || liveness !== undefined;
1002
1224
 
@@ -1005,7 +1227,9 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1005
1227
  const parents: number[] = [];
1006
1228
  const actions: (string | undefined)[] = [];
1007
1229
  const depths: number[] = [];
1008
- const buckets = new Map<number, number | number[]>();
1230
+ // A Map holds at most 2^24 entries, so an open-addressing table keeps each seen state's hash
1231
+ // and its index plus one side by side, probed by the hash.
1232
+ const seen = { slots: new Int32Array(1 << 17), size: 0, shift: 16 };
1009
1233
  const canonicalizeState = createCanonicalizer();
1010
1234
 
1011
1235
  const toRecord = (state: Value[]): Record<string, Value> =>
@@ -1018,11 +1242,16 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1018
1242
  position: number,
1019
1243
  loopStart: number | undefined,
1020
1244
  ) => {
1021
- const state = steps[position].state;
1022
- const next = (steps[position + 1] ?? steps[loopStart ?? position]).state;
1023
1245
  // TLC evaluates TLCGet("level") and Trace in an alias at the state's position in the trace.
1024
1246
  runtime.getLevel = () => position + 1;
1025
1247
  runtime.getBehavior = () => steps.slice(0, position + 1).map((step) => step.state);
1248
+ return evaluateAlias(
1249
+ alias,
1250
+ steps[position].state,
1251
+ (steps[position + 1] ?? steps[loopStart ?? position]).state,
1252
+ );
1253
+ };
1254
+ const evaluateAlias = (alias: string, state: Value[], next: Value[] | undefined) => {
1026
1255
  try {
1027
1256
  const body = getConfigDefinition("alias", alias, environment).body;
1028
1257
  const value = evaluate(createIdentifier(alias), getContext(environment, state, next));
@@ -1124,7 +1353,17 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1124
1353
  trace: TraceStep[],
1125
1354
  initialState?: Value[],
1126
1355
  failureOutDegrees?: number[],
1127
- ) => {
1356
+ ): CheckResult => {
1357
+ // TLC exits with 255 on a stack overflow while it computes next states, and prints the
1358
+ // behavior up to the state it was expanding.
1359
+ if (isStackOverflow(error)) {
1360
+ return current.isExpanding
1361
+ ? toFailure(
1362
+ setExitCode(new TlaEvaluationError(STACK_OVERFLOW), EXIT_STATUS.error),
1363
+ getStateTrace(current.index),
1364
+ )
1365
+ : toFailure(new TlaEvaluationError(STACK_OVERFLOW), trace, initialState);
1366
+ }
1128
1367
  if (!(error instanceof TlaEvaluationError)) throw error;
1129
1368
  return {
1130
1369
  ...createResult("error", undefined, {
@@ -1152,6 +1391,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1152
1391
  let hash = 0x811c9dc5;
1153
1392
  for (let index = 0; index < state.length; index++)
1154
1393
  hash = combineHash(hash, getValueHash(state[index]));
1394
+ assertFingerprintable(state);
1155
1395
  return hash & 0x3fffffff;
1156
1396
  };
1157
1397
  const isSameState = (stored: Value[], state: Value[]) => {
@@ -1160,19 +1400,35 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1160
1400
  }
1161
1401
  return true;
1162
1402
  };
1403
+ const getSlot = (hash: number) => (Math.imul(hash, 0x9e3779b1) >>> seen.shift) << 1;
1163
1404
  const findStateIndex = (hash: number, state: Value[]) => {
1164
- const bucket = buckets.get(hash);
1165
- if (bucket === undefined) return -1;
1166
- if (typeof bucket === "number") {
1167
- return isSameState(fingerprintStates[bucket], state) ? bucket : -1;
1405
+ const mask = seen.slots.length - 1;
1406
+ for (let slot = getSlot(hash); ; slot = (slot + 2) & mask) {
1407
+ const entry = seen.slots[slot + 1];
1408
+ if (entry === 0) return -1;
1409
+ if (seen.slots[slot] === hash && isSameState(fingerprintStates[entry - 1], state)) {
1410
+ return entry - 1;
1411
+ }
1168
1412
  }
1169
- return bucket.find((index) => isSameState(fingerprintStates[index], state)) ?? -1;
1413
+ };
1414
+ const insertSeen = (hash: number, entry: number) => {
1415
+ const mask = seen.slots.length - 1;
1416
+ let slot = getSlot(hash);
1417
+ while (seen.slots[slot + 1] !== 0) slot = (slot + 2) & mask;
1418
+ seen.slots[slot] = hash;
1419
+ seen.slots[slot + 1] = entry;
1170
1420
  };
1171
1421
  const markSeen = (hash: number, index: number) => {
1172
- const bucket = buckets.get(hash);
1173
- if (bucket === undefined) buckets.set(hash, index);
1174
- else if (typeof bucket === "number") buckets.set(hash, [bucket, index]);
1175
- else bucket.push(index);
1422
+ seen.size++;
1423
+ if (seen.size * 4 > seen.slots.length) {
1424
+ const slots = seen.slots;
1425
+ seen.slots = new Int32Array(slots.length * 2);
1426
+ seen.shift--;
1427
+ for (let slot = 0; slot < slots.length; slot += 2) {
1428
+ if (slots[slot + 1] !== 0) insertSeen(slots[slot], slots[slot + 1]);
1429
+ }
1430
+ }
1431
+ insertSeen(hash, index + 1);
1176
1432
  };
1177
1433
  const countDistinctState = (depth: number) => {
1178
1434
  runtime.distinctStates = states.length + 1;
@@ -1198,6 +1454,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1198
1454
  isExpanding: false,
1199
1455
  candidate: undefined as Value[] | undefined,
1200
1456
  candidateLevel: 0,
1457
+ isFingerprinting: false,
1201
1458
  livenessSource: -1,
1202
1459
  };
1203
1460
  const getPath = (index: number): Value[][] =>
@@ -1223,6 +1480,18 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1223
1480
  return current.isExpanding ? depths[current.index] + 1 : 0;
1224
1481
  };
1225
1482
 
1483
+ const getGraphState = (state: Value[], level: number): GraphState => ({
1484
+ fingerprint: BigInt.asIntN(64, runtime.getFingerprint(state)),
1485
+ level,
1486
+ getLabel: () =>
1487
+ formatState(
1488
+ config.alias === undefined
1489
+ ? toRecord(state)
1490
+ : evaluateAlias(config.alias, state, undefined),
1491
+ ),
1492
+ getText: () => formatState(toRecord(state)),
1493
+ });
1494
+
1226
1495
  const visitInitialState = (state: Value[]) => {
1227
1496
  canonicalizeState(state);
1228
1497
  runtime.generatedStates++;
@@ -1239,6 +1508,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1239
1508
  countDistinctState(1);
1240
1509
  runtime.queueSize++;
1241
1510
  liveness?.addInitialState(states.length, state);
1511
+ stateWriter?.writeInitialState(getGraphState(state, 1));
1242
1512
  }
1243
1513
  const violated = search.findViolatedInvariant(state);
1244
1514
  if (violated) {
@@ -1259,20 +1529,36 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1259
1529
  addState(state, fingerprintState, -1, undefined);
1260
1530
  return undefined;
1261
1531
  };
1262
- const visitSuccessor = (index: number, successor: Successor, liveSuccessors: LiveSuccessor[]) => {
1532
+ const visitSuccessor = (
1533
+ index: number,
1534
+ successor: Successor,
1535
+ liveSuccessors: LiveSuccessor[],
1536
+ source: GraphState | undefined,
1537
+ action: SpecAction | undefined,
1538
+ ) => {
1263
1539
  const state = states[index];
1264
1540
  runtime.generatedStates++;
1265
1541
  current.candidate = successor.state;
1266
1542
  current.candidateLevel = depths[index] + 1;
1267
1543
  if (isCanonicalizedFirst) canonicalizeState(successor.state);
1544
+ current.isFingerprinting = true;
1268
1545
  const fingerprintState = getFingerprintState(successor.state);
1269
1546
  const hash = getStateHash(fingerprintState);
1547
+ current.isFingerprinting = false;
1270
1548
  const found = findStateIndex(hash, fingerprintState);
1271
1549
  const isStateInModel = search.satisfiesConstraints(successor.state, state);
1272
1550
  if (isStateInModel) search.trackStatePossible(successor.state);
1273
1551
  const isInModel = isStateInModel && search.satisfiesActionConstraints(state, successor.state);
1274
1552
  if (isInModel) search.trackActionPossible(state, successor.state);
1275
1553
  const existing = isInModel ? found : -1;
1554
+ if (source && isInModel) {
1555
+ stateWriter?.writeSuccessor(
1556
+ source,
1557
+ getGraphState(successor.state, depths[index] + 1),
1558
+ existing !== -1,
1559
+ action && { name: action.name, signature: getActionSignature(action) },
1560
+ );
1561
+ }
1276
1562
  if (existing !== -1 && liveness) {
1277
1563
  const stored = states[existing];
1278
1564
  const isStored = stored.every((value, position) => value === successor.state[position]);
@@ -1330,10 +1616,22 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1330
1616
  spec.scope,
1331
1617
  );
1332
1618
  } catch (error) {
1333
- return toFailure(error, []);
1619
+ if (!(error instanceof TlaIllegalStateError))
1620
+ return replayInitialStates(toFailure(error, []));
1621
+ // TLC prints an illegal initial state with null for each variable it leaves undefined, and
1622
+ // stops before it prints the statistics.
1623
+ const illegal = toFailure(
1624
+ error,
1625
+ [],
1626
+ error.state.map((value) => value ?? createModelValue("null")),
1627
+ );
1628
+ return {
1629
+ ...illegal,
1630
+ failure: illegal.failure && { ...illegal.failure, isWithoutStatistics: true },
1631
+ };
1334
1632
  }
1335
1633
  }
1336
- if (outcome.result) return outcome.result;
1634
+ if (outcome.result) return replayInitialStates(outcome.result);
1337
1635
 
1338
1636
  const next = spec.next;
1339
1637
  if (next === undefined) {
@@ -1344,23 +1642,58 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1344
1642
  }
1345
1643
  return createSuccess();
1346
1644
  }
1645
+ // TLC labels and colors an edge of the -dump state graph by the action that generated it. When
1646
+ // the graph names its edges, the search generates successors action by action, as TLC does.
1647
+ const isNamingEdges = Boolean(
1648
+ options.dump?.dot && (options.dump.actionLabels || options.dump.colorize),
1649
+ );
1650
+ const forEachActionSuccessor = (
1651
+ state: Value[],
1652
+ onSuccessor: (successor: Successor, action: SpecAction | undefined) => boolean,
1653
+ ) => {
1654
+ if (!isNamingEdges) {
1655
+ return forEachSuccessor(
1656
+ next,
1657
+ state,
1658
+ environment,
1659
+ (successor) => onSuccessor(successor, undefined),
1660
+ spec.scope,
1661
+ );
1662
+ }
1663
+ nextActions.value ??= getNextActions(config, environment, specification.instanceActions);
1664
+ const progress = { isStopped: false };
1665
+ return nextActions.value.reduce((count, action) => {
1666
+ if (progress.isStopped) return count;
1667
+ return (
1668
+ count +
1669
+ forEachSuccessor(
1670
+ action.expression,
1671
+ state,
1672
+ environment,
1673
+ (successor) => {
1674
+ progress.isStopped = onSuccessor(successor, action);
1675
+ return progress.isStopped;
1676
+ },
1677
+ action.scope,
1678
+ )
1679
+ );
1680
+ }, 0);
1681
+ };
1347
1682
  const expandState = (index: number) => {
1348
1683
  const state = states[index];
1349
1684
  const liveSuccessors: LiveSuccessor[] = [];
1350
- const successorCount = forEachSuccessor(
1351
- next,
1352
- state,
1353
- environment,
1354
- (successor) => {
1355
- try {
1356
- outcome.result = visitSuccessor(index, successor, liveSuccessors);
1357
- } catch (error) {
1358
- outcome.result = toFailure(error, getTrace(index, successor));
1359
- }
1360
- return outcome.result !== undefined;
1361
- },
1362
- spec.scope,
1363
- );
1685
+ const source = stateWriter && getGraphState(state, depths[index]);
1686
+ const successorCount = forEachActionSuccessor(state, (successor, action) => {
1687
+ try {
1688
+ outcome.result = visitSuccessor(index, successor, liveSuccessors, source, action);
1689
+ } catch (error) {
1690
+ // TLC reports a successor it cannot fingerprint as a failure of the state it expands.
1691
+ if (current.isFingerprinting) throw error;
1692
+ const failure = toFailure(error, getTrace(index, successor));
1693
+ outcome.result = isStackOverflow(error) ? failure : replaySuccessors(failure, index);
1694
+ }
1695
+ return outcome.result !== undefined;
1696
+ });
1364
1697
  current.isExpanding = false;
1365
1698
  if (outcome.result) return outcome.result;
1366
1699
  if (successorCount === 0 && config.checkDeadlock) {
@@ -1380,9 +1713,44 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1380
1713
  trace: toTrace(steps, accepted),
1381
1714
  });
1382
1715
  } catch (error) {
1383
- return toFailure(error, getStateTrace(index), undefined, getPartialOutDegrees());
1716
+ return replayFailure(
1717
+ toFailure(toNextStateError(error), getStateTrace(index), undefined, getPartialOutDegrees()),
1718
+ (_, traced) =>
1719
+ createLivenessChecker(
1720
+ search.properties.liveness,
1721
+ spec.temporals,
1722
+ traced,
1723
+ liveGraph,
1724
+ )?.addState(index, state, liveSuccessors),
1725
+ true,
1726
+ );
1384
1727
  }
1385
1728
  };
1729
+ // TLC names the action when the next-state relation has more than one, and prints the
1730
+ // incomplete successor with null for each variable it leaves undefined.
1731
+ const reportIncompleteSuccessor = (error: TlaIncompleteStateError, index: number) => {
1732
+ nextActions.value ??= getNextActions(config, environment, specification.instanceActions);
1733
+ const actions = nextActions.value;
1734
+ const action =
1735
+ actions.length === 1 ? actions[0] : actions.find((item) => item.name === error.action);
1736
+ const variables = `variable${error.missing.length > 1 ? "s are" : " is"} not defined: ${error.missing.join(", ")}.\n`;
1737
+ runtime.generatedStates++;
1738
+ return toFailure(
1739
+ actions.length === 1
1740
+ ? error
1741
+ : new TlaEvaluationError(
1742
+ `Successor state is not completely specified by action ${error.action} of the next-state relation. The following ${variables}`,
1743
+ ),
1744
+ [
1745
+ ...getStateTrace(index),
1746
+ {
1747
+ action: error.action,
1748
+ label: action && getActionLabel(action),
1749
+ state: toRecord(error.state.map((value) => value ?? createModelValue("null"))),
1750
+ },
1751
+ ],
1752
+ );
1753
+ };
1386
1754
  // TLC names the properties and the step back into the cycle from the states it prints.
1387
1755
  const reportLasso = (checker: LivenessChecker, lasso: Lasso) => {
1388
1756
  const path = [...lasso.prefix, ...lasso.cycle];
@@ -1420,7 +1788,6 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1420
1788
  periodic.time += performance.now() - now;
1421
1789
  return lasso;
1422
1790
  };
1423
- setNextStatePhase(true);
1424
1791
  for (let index = 0; index < states.length && !runtime.isStopped; index++) {
1425
1792
  current.index = index;
1426
1793
  current.candidate = undefined;
@@ -1429,7 +1796,14 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1429
1796
  try {
1430
1797
  outcome.result = expandState(index);
1431
1798
  } catch (error) {
1432
- outcome.result = toFailure(error, getStateTrace(index));
1799
+ const failure =
1800
+ error instanceof TlaIncompleteStateError
1801
+ ? reportIncompleteSuccessor(error, index)
1802
+ : toFailure(toNextStateError(error), getStateTrace(index));
1803
+ outcome.result =
1804
+ error instanceof TlaIncompleteStateError || isStackOverflow(error)
1805
+ ? failure
1806
+ : replaySuccessors(failure, index);
1433
1807
  }
1434
1808
  if (outcome.result) return outcome.result;
1435
1809
  outDegrees[getOutDegreeBucket()]++;