tla-ts 0.0.3-dev.5ea4534 → 0.0.3-dev.5fd6731

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 (49) hide show
  1. package/dist/index.cjs +1 -1
  2. package/dist/index.d.cts +59 -22
  3. package/dist/index.d.ts +59 -22
  4. package/dist/index.js +1 -1
  5. package/dist/parallel-worker.cjs +1 -1
  6. package/dist/parallel-worker.js +2 -2
  7. package/dist/parallel.cjs +1 -1
  8. package/dist/parallel.js +2 -2
  9. package/dist/run-cli.cjs +14 -12
  10. package/dist/run-cli.js +22 -20
  11. package/dist/transfer.cjs +39 -21
  12. package/dist/transfer.js +39 -21
  13. package/package.json +1 -1
  14. package/src/ast.ts +27 -4
  15. package/src/builtins.ts +9 -3
  16. package/src/check.ts +357 -79
  17. package/src/codegen.ts +6 -3
  18. package/src/config.ts +224 -170
  19. package/src/environment.ts +249 -87
  20. package/src/errors.ts +100 -1
  21. package/src/evaluate.ts +182 -26
  22. package/src/exit-codes.ts +22 -3
  23. package/src/fingerprints.ts +2 -1
  24. package/src/instances.ts +1 -1
  25. package/src/levels.ts +177 -36
  26. package/src/live-check.ts +132 -70
  27. package/src/liveness.ts +117 -22
  28. package/src/parallel-worker.ts +2 -2
  29. package/src/parallel.ts +2 -2
  30. package/src/parser.ts +155 -49
  31. package/src/resolve.ts +911 -342
  32. package/src/run-cli.ts +61 -11
  33. package/src/sany-lexer.ts +615 -0
  34. package/src/sany-parse-error.ts +3143 -0
  35. package/src/spec-description.ts +1 -2
  36. package/src/standard-modules.ts +54 -45
  37. package/src/standard-ranges.ts +116 -0
  38. package/src/subexpressions.ts +26 -14
  39. package/src/substitution-levels.ts +38 -17
  40. package/src/successors.ts +169 -33
  41. package/src/symmetry.ts +16 -6
  42. package/src/tableau.ts +51 -24
  43. package/src/tlc-module.ts +6 -6
  44. package/src/tlc-modules.ts +4 -0
  45. package/src/tlc-order.ts +8 -4
  46. package/src/tlc-random.ts +9 -6
  47. package/src/tlc-summary.ts +20 -5
  48. package/src/value-sources.ts +29 -0
  49. package/src/values.ts +231 -61
package/src/check.ts CHANGED
@@ -11,8 +11,13 @@ import { getReadVariables } from "./dependencies";
11
11
  import { createEnvironment } from "./environment";
12
12
  import {
13
13
  getErrorExitCode,
14
+ isStackOverflow,
15
+ formatRange,
16
+ STACK_OVERFLOW,
14
17
  TlaConfigError,
15
18
  TlaEvaluationError,
19
+ TlaIllegalStateError,
20
+ TlaIncompleteStateError,
16
21
  TlaModuleError,
17
22
  UNEXPECTED_EXCEPTION,
18
23
  } from "./errors";
@@ -21,7 +26,6 @@ import {
21
26
  describeRange,
22
27
  evaluate,
23
28
  expectBoolean,
24
- formatRange,
25
29
  getDefinition,
26
30
  isConstantLevel,
27
31
  isImpure,
@@ -32,6 +36,7 @@ import {
32
36
  import {
33
37
  createLivenessChecker,
34
38
  type Lasso,
39
+ type LiveGraph,
35
40
  type LivenessChecker,
36
41
  type LiveSuccessor,
37
42
  } from "./live-check";
@@ -59,14 +64,17 @@ import {
59
64
  type StateWriter,
60
65
  } from "./state-graph";
61
66
  import { getRepresentative, getSymmetryGroup } from "./symmetry";
62
- import { getTlcStringOrder, getTlcVariableOrder } from "./tlc-order";
67
+ import { getTlcStringOrder, getTlcDeclarationOrder } from "./tlc-order";
63
68
  import { createTlcFingerprinter, getTlcFingerprint } from "./tlc-random";
64
69
  import { createCanonicalizer } from "./canonical";
65
70
  import { getPossibleCounts, type CheckerRuntime } from "./runtime";
66
71
  import { createCounterExample } from "./tlc-ext";
72
+ import { getFingerprintTrace, valueSources } from "./value-sources";
67
73
  import { getFingerprintDistance, OUT_DEGREE_BUCKETS } from "./tlc-summary";
68
74
  import {
75
+ assertFingerprintable,
69
76
  combineHash,
77
+ createModelValue,
70
78
  formatState,
71
79
  formatValue,
72
80
  getValueHash,
@@ -136,6 +144,25 @@ export interface EvaluationFailure {
136
144
  trace: TraceStep[];
137
145
  initialState: Record<string, Value> | undefined;
138
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;
139
166
  }
140
167
 
141
168
  export interface CheckResult {
@@ -247,7 +274,7 @@ const getConstantValue = (name: string, definition: Definition, environment: Env
247
274
  try {
248
275
  return evaluate(createIdentifier(name), getContext(environment, undefined, undefined));
249
276
  } catch (error) {
250
- if (error instanceof TlaEvaluationError) return undefined;
277
+ if (error instanceof TlaEvaluationError || isStackOverflow(error)) return undefined;
251
278
  throw error;
252
279
  }
253
280
  };
@@ -276,8 +303,11 @@ const getInvariants = (names: string[], environment: Environment) => {
276
303
  levels.params.size === 0
277
304
  ? ""
278
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.";
279
- throw new TlaConfigError(
280
- `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,
281
311
  );
282
312
  }
283
313
  return [{ name, expression: createIdentifier(name), scope: undefined }];
@@ -375,8 +405,11 @@ const getSpecification = (config: ModelConfig, environment: Environment): Specif
375
405
  conjunct.kind === "Always" &&
376
406
  getLevel(conjunct.expression, item.scope, environment) < ACTION_LEVEL
377
407
  ) {
378
- throw new TlaConfigError(
379
- `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,
380
413
  );
381
414
  }
382
415
  const level = getLevel(conjunct, item.scope, environment);
@@ -446,12 +479,12 @@ const getProperties = (config: ModelConfig, environment: Environment): Propertie
446
479
  config.properties.forEach((name) => {
447
480
  const definition = getConfigPredicate("property", name, environment);
448
481
  if (!definition) return;
449
- expandTemporal(definition.body, undefined, environment, true).forEach((item) => {
482
+ expandTemporal(definition.body, undefined, environment, true, name).forEach((item) => {
450
483
  const conjunct = item.expression;
451
484
  if (isConstantTrue(item, environment, "property")) return;
452
485
  if (conjunct.kind === "Always" && conjunct.expression.kind === "BoxAction") {
453
486
  properties.actionProperties.push({
454
- name,
487
+ name: item.name,
455
488
  box: conjunct.expression,
456
489
  action: conjunct.expression.action,
457
490
  subscript: conjunct.expression.subscript,
@@ -463,12 +496,22 @@ const getProperties = (config: ModelConfig, environment: Environment): Propertie
463
496
  conjunct.kind === "Always" &&
464
497
  getLevel(conjunct.expression, item.scope, environment) <= 1
465
498
  ) {
466
- 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
+ });
467
506
  return;
468
507
  }
469
508
  const level = getLevel(conjunct, item.scope, environment);
470
509
  if (level < ACTION_LEVEL) {
471
- 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
+ });
472
515
  return;
473
516
  }
474
517
  if (level === ACTION_LEVEL) {
@@ -777,11 +820,13 @@ export const createSearch = (
777
820
  if (view !== undefined || isFingerprintedLikeTlc) {
778
821
  return BigInt64Array.from(states, getTlcStateFingerprint);
779
822
  }
780
- const indices = getTlcOrder();
781
- const getFingerprint = createTlcFingerprinter();
782
- return BigInt64Array.from(fingerprintStates, (state) =>
783
- getFingerprint(indices.map((index) => state[index])),
823
+ const fingerprints = new BigInt64Array(fingerprintStates.length);
824
+ const fingerprint = createTlcFingerprinter(
825
+ getTlcOrder(),
826
+ new Int32Array(fingerprints.buffer),
784
827
  );
828
+ fingerprintStates.forEach(fingerprint);
829
+ return fingerprints;
785
830
  },
786
831
  getFingerprintState: (state) => {
787
832
  if (isFingerprintedLikeTlc) return [String(getTlcStateFingerprint(state))];
@@ -813,11 +858,17 @@ export const createSearch = (
813
858
  }
814
859
  }),
815
860
  satisfiesConstraints: (state, parent) =>
816
- constraints.every(
817
- (constraint) =>
818
- isUnchangedFor(constraint, state, parent) ||
819
- holdsLikeTlc(constraint.expression, getContext(environment, state, undefined)),
820
- ),
861
+ constraints.every((constraint) => {
862
+ try {
863
+ return (
864
+ isUnchangedFor(constraint, state, parent) ||
865
+ holdsLikeTlc(constraint.expression, getContext(environment, state, undefined))
866
+ );
867
+ } catch (error) {
868
+ // TLC reports a failing constraint on a successor like a failure of the next-state relation.
869
+ throw parent ? toNextStateError(error) : error;
870
+ }
871
+ }),
821
872
  findFailedInitialPredicate: (state) =>
822
873
  properties.initialPredicates.find(
823
874
  (predicate) =>
@@ -850,13 +901,13 @@ export const createSearch = (
850
901
  }
851
902
  }),
852
903
  satisfiesActionConstraints: (state, next) =>
853
- actionConstraints.every((constraint) =>
854
- holdsLikeTlc(
855
- constraint.expression,
856
- getContext(environment, state, next),
857
- (expression) => `${UNEXPECTED_EXCEPTION}${getExpectedBoolean(expression, environment)}`,
858
- ),
859
- ),
904
+ actionConstraints.every((constraint) => {
905
+ try {
906
+ return holdsLikeTlc(constraint.expression, getContext(environment, state, next));
907
+ } catch (error) {
908
+ throw toNextStateError(error);
909
+ }
910
+ }),
860
911
  trackStatePossible:
861
912
  statePossible.length === 0
862
913
  ? ignorePossible
@@ -887,6 +938,59 @@ export const createSearch = (
887
938
  const withNextStateExitCode = (error: unknown) =>
888
939
  error instanceof TlaModuleError ? setExitCode(error, error.exitCode) : error;
889
940
 
941
+ // TLC reports a failure of the next-state relation, or of the liveness check of a step, as an
942
+ // unexpected exception, unless a standard module raised it as an EvalException.
943
+ const toNextStateError = (error: unknown) =>
944
+ error instanceof TlaEvaluationError &&
945
+ !(error instanceof TlaModuleError) &&
946
+ !(error instanceof TlaIncompleteStateError)
947
+ ? setExitCode(
948
+ new TlaEvaluationError(`${UNEXPECTED_EXCEPTION}${error.message}`, error),
949
+ getErrorExitCode(error),
950
+ )
951
+ : withNextStateExitCode(error);
952
+
953
+ const isRepeated = (frame: string, index: number, frames: string[]) =>
954
+ index > 0 && frames[index - 1] === frame;
955
+
956
+ // FingerprintException#getTrace numbers the sources from the outermost value and lists the innermost
957
+ // first.
958
+ const getSourceTrace = (sources: Expression[]) =>
959
+ sources
960
+ .flatMap((source) => (source.location.range ? [formatRange(source.location.range)] : []))
961
+ .filter((source, index, all) => !isRepeated(source, index, all))
962
+ .map((source, index) => `${index}) ${source}`)
963
+ .reverse();
964
+
965
+ // TLC keeps the stack only when an evaluation fails, and prints each expression on it once, however
966
+ // many times in a row it pushed it.
967
+ const getReplayedCallStack = (
968
+ replay: () => void,
969
+ trace: Expression[],
970
+ ): Pick<Replay, "callStack" | "fingerprint"> => {
971
+ try {
972
+ replay();
973
+ return { callStack: undefined };
974
+ } catch (error) {
975
+ if (!(error instanceof TlaEvaluationError)) return { callStack: [] };
976
+ const callStack = trace
977
+ .flatMap((expression) => {
978
+ const range = expression.location.range;
979
+ return range
980
+ ? [
981
+ `Line ${range.start.line}, column ${range.start.column} to line ${range.end.line}, column ${range.end.column} in ${range.module}`,
982
+ ]
983
+ : [];
984
+ })
985
+ .filter((frame, index, frames) => !isRepeated(frame, index, frames));
986
+ const sources = getFingerprintTrace(error);
987
+ return {
988
+ callStack,
989
+ fingerprint: sources && { sources: getSourceTrace(sources), reason: error.message },
990
+ };
991
+ }
992
+ };
993
+
890
994
  const withHeadline = (error: unknown, headline: string) =>
891
995
  error instanceof TlaEvaluationError
892
996
  ? setExitCode(
@@ -898,9 +1002,16 @@ const withHeadline = (error: unknown, headline: string) =>
898
1002
  // TLC finishes the -dump file whether or not the search finds a violation.
899
1003
  export const checkSequentially = (options: CheckOptions): CheckResult => {
900
1004
  const stateWriter = options.dump && createStateWriter(options.dump, options.writeFile);
901
- const result = searchStates(options, stateWriter);
902
- stateWriter?.close();
903
- return result;
1005
+ try {
1006
+ return searchStates(options, stateWriter);
1007
+ } catch (error) {
1008
+ // TLC reports a stack overflow outside the search as a failure of its own, with exit code 255.
1009
+ throw isStackOverflow(error)
1010
+ ? setExitCode(new TlaEvaluationError(STACK_OVERFLOW), EXIT_STATUS.error)
1011
+ : error;
1012
+ } finally {
1013
+ stateWriter?.close();
1014
+ }
904
1015
  };
905
1016
 
906
1017
  const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefined): CheckResult => {
@@ -908,9 +1019,10 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
908
1019
  const onPrint = options.onPrint ?? console.log;
909
1020
  // TLC prints again while it rebuilds a trace, between the states it prints. Printing those lines
910
1021
  // before the trace would misplace them, so rebuilding a trace prints nothing.
911
- const output = { isMuted: false };
1022
+ const output = { isMuted: false, replayed: undefined as string[] | undefined };
912
1023
  const print = (text: string) => {
913
- if (!output.isMuted) onPrint(text);
1024
+ if (output.replayed) output.replayed.push(text);
1025
+ else if (!output.isMuted) onPrint(text);
914
1026
  };
915
1027
  const withoutOutput = <Result>(rebuild: () => Result) => {
916
1028
  output.isMuted = true;
@@ -972,9 +1084,9 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
972
1084
  ),
973
1085
  });
974
1086
 
975
- const search = createSearch(config, environment, () =>
976
- getTlcVariableOrder(options.source, options.loadModule),
977
- );
1087
+ const getVariableOrder = () =>
1088
+ getTlcDeclarationOrder(options.source, options.loadModule, "variable");
1089
+ const search = createSearch(config, environment, getVariableOrder);
978
1090
  const assumptionViolation = findAssumptionViolation(specification.assumptions, environment);
979
1091
  if (assumptionViolation) return createResult("assumption-violation", assumptionViolation);
980
1092
  if (!search) return createSuccess();
@@ -998,37 +1110,114 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
998
1110
  const spec = search.spec;
999
1111
  const getFingerprintState = search.getFingerprintState;
1000
1112
  const nextActions = { value: undefined as SpecAction[] | undefined };
1113
+ const replayFailure = (
1114
+ result: CheckResult,
1115
+ replay: (tracedSearch: Search, traced: Environment) => void,
1116
+ isBeforeError = false,
1117
+ ): CheckResult => {
1118
+ if (!result.failure) return result;
1119
+ const trace: Expression[] = [];
1120
+ const traced: Environment = { ...environment, evaluators: new WeakMap(), trace };
1121
+ const tracedSearch = createSearch(config, traced, getVariableOrder);
1122
+ if (!tracedSearch) return result;
1123
+ const replayed: string[] = [];
1124
+ output.replayed = replayed;
1125
+ valueSources.current = new WeakMap();
1126
+ const replayedStack = getReplayedCallStack(() => replay(tracedSearch, traced), trace);
1127
+ valueSources.current = undefined;
1128
+ output.replayed = undefined;
1129
+ return {
1130
+ ...result,
1131
+ failure: { ...result.failure, replay: { output: replayed, ...replayedStack, isBeforeError } },
1132
+ };
1133
+ };
1134
+ // TLC fingerprints a state outside CallStackTool, so a failure of a value with a source leaves
1135
+ // the stack empty. Any other failure keeps the stack of the initial predicate.
1136
+ const fingerprintReplayed = (state: Value[], traced: Environment) => {
1137
+ try {
1138
+ getStateHash(getFingerprintState(state));
1139
+ } catch (error) {
1140
+ if (traced.trace && getFingerprintTrace(error)) traced.trace.length = 0;
1141
+ throw error;
1142
+ }
1143
+ };
1144
+ // TLC checks every initial state again, as when it first generated them.
1145
+ const replayInitialStates = (result: CheckResult) =>
1146
+ replayFailure(result, (tracedSearch, traced) => {
1147
+ if (spec.init === undefined) return;
1148
+ forEachInitialState(
1149
+ spec.init,
1150
+ traced,
1151
+ (state) => {
1152
+ if (tracedSearch.satisfiesConstraints(state)) fingerprintReplayed(state, traced);
1153
+ return (
1154
+ tracedSearch.findViolatedInvariant(state) !== undefined ||
1155
+ tracedSearch.findFailedInitialPredicate(state) !== undefined
1156
+ );
1157
+ },
1158
+ spec.scope,
1159
+ );
1160
+ });
1161
+ // TLC rebuilds the behavior up to the state it expanded before it replays the step.
1162
+ const rebuildBehavior = (index: number): void => {
1163
+ const parent = parents[index];
1164
+ if (parent === -1) {
1165
+ getSpecInitialStates();
1166
+ return;
1167
+ }
1168
+ rebuildBehavior(parent);
1169
+ getLabel(parent, states[parent], states[index]);
1170
+ };
1171
+ // TLC generates the successors of each action before it checks them. It checks the invariants
1172
+ // only of a successor outside the model, since it has seen the others.
1173
+ const replaySuccessors = (result: CheckResult, index: number) =>
1174
+ replayFailure(result, (tracedSearch, traced) => {
1175
+ rebuildBehavior(index);
1176
+ const state = states[index];
1177
+ nextActions.value ??= getNextActions(config, environment, specification.instanceActions);
1178
+ nextActions.value.find((action) =>
1179
+ getSuccessors(action.expression, state, traced, action.scope).some((successor) => {
1180
+ const isInModel =
1181
+ tracedSearch.satisfiesConstraints(successor.state) &&
1182
+ tracedSearch.satisfiesActionConstraints(state, successor.state);
1183
+ if (isInModel) fingerprintReplayed(successor.state, traced);
1184
+ return (
1185
+ (!isInModel && tracedSearch.findViolatedInvariant(successor.state) !== undefined) ||
1186
+ tracedSearch.findViolatedActionProperty(state, successor.state) !== undefined
1187
+ );
1188
+ }),
1189
+ );
1190
+ });
1001
1191
  const isReducing = config.view !== undefined || config.symmetry !== undefined;
1002
1192
  const tlcFingerprints: number[] = [];
1193
+ const liveGraph: LiveGraph = {
1194
+ getFingerprint: (index) =>
1195
+ (tlcFingerprints[index] ??= Number(BigInt.asIntN(32, runtime.getFingerprint(states[index])))),
1196
+ getSuccessors: (state) => {
1197
+ const successors: LiveSuccessor[] = [];
1198
+ if (spec.next === undefined) return successors;
1199
+ forEachSuccessor(
1200
+ spec.next,
1201
+ state,
1202
+ environment,
1203
+ (successor) => {
1204
+ canonicalizeState(successor.state);
1205
+ const isInModel =
1206
+ search.satisfiesConstraints(successor.state, state) &&
1207
+ search.satisfiesActionConstraints(state, successor.state);
1208
+ if (!isInModel) return false;
1209
+ const fingerprintState = getFingerprintState(successor.state);
1210
+ const index = findStateIndex(getStateHash(fingerprintState), fingerprintState);
1211
+ successors.push({ index, state: successor.state });
1212
+ return false;
1213
+ },
1214
+ spec.scope,
1215
+ );
1216
+ return successors;
1217
+ },
1218
+ };
1003
1219
  const liveness = withLivenessExitCode(() =>
1004
- createLivenessChecker(search.properties.liveness, spec.temporals, environment, {
1005
- getFingerprint: (index) =>
1006
- (tlcFingerprints[index] ??= Number(
1007
- BigInt.asIntN(32, runtime.getFingerprint(states[index])),
1008
- )),
1009
- getSuccessors: (state) => {
1010
- const successors: LiveSuccessor[] = [];
1011
- if (spec.next === undefined) return successors;
1012
- forEachSuccessor(
1013
- spec.next,
1014
- state,
1015
- environment,
1016
- (successor) => {
1017
- canonicalizeState(successor.state);
1018
- const isInModel =
1019
- search.satisfiesConstraints(successor.state, state) &&
1020
- search.satisfiesActionConstraints(state, successor.state);
1021
- if (!isInModel) return false;
1022
- const fingerprintState = getFingerprintState(successor.state);
1023
- const index = findStateIndex(getStateHash(fingerprintState), fingerprintState);
1024
- successors.push({ index, state: successor.state });
1025
- return false;
1026
- },
1027
- spec.scope,
1028
- );
1029
- return successors;
1030
- },
1031
- }),
1220
+ createLivenessChecker(search.properties.liveness, spec.temporals, environment, liveGraph),
1032
1221
  );
1033
1222
  const isCanonicalizedFirst = search.isSymmetric || liveness !== undefined;
1034
1223
 
@@ -1037,7 +1226,9 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1037
1226
  const parents: number[] = [];
1038
1227
  const actions: (string | undefined)[] = [];
1039
1228
  const depths: number[] = [];
1040
- const buckets = new Map<number, number | number[]>();
1229
+ // A Map holds at most 2^24 entries, so an open-addressing table keeps each seen state's hash
1230
+ // and its index plus one side by side, probed by the hash.
1231
+ const seen = { slots: new Int32Array(1 << 17), size: 0, shift: 16 };
1041
1232
  const canonicalizeState = createCanonicalizer();
1042
1233
 
1043
1234
  const toRecord = (state: Value[]): Record<string, Value> =>
@@ -1161,7 +1352,17 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1161
1352
  trace: TraceStep[],
1162
1353
  initialState?: Value[],
1163
1354
  failureOutDegrees?: number[],
1164
- ) => {
1355
+ ): CheckResult => {
1356
+ // TLC exits with 255 on a stack overflow while it computes next states, and prints the
1357
+ // behavior up to the state it was expanding.
1358
+ if (isStackOverflow(error)) {
1359
+ return current.isExpanding
1360
+ ? toFailure(
1361
+ setExitCode(new TlaEvaluationError(STACK_OVERFLOW), EXIT_STATUS.error),
1362
+ getStateTrace(current.index),
1363
+ )
1364
+ : toFailure(new TlaEvaluationError(STACK_OVERFLOW), trace, initialState);
1365
+ }
1165
1366
  if (!(error instanceof TlaEvaluationError)) throw error;
1166
1367
  return {
1167
1368
  ...createResult("error", undefined, {
@@ -1189,6 +1390,7 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1189
1390
  let hash = 0x811c9dc5;
1190
1391
  for (let index = 0; index < state.length; index++)
1191
1392
  hash = combineHash(hash, getValueHash(state[index]));
1393
+ assertFingerprintable(state);
1192
1394
  return hash & 0x3fffffff;
1193
1395
  };
1194
1396
  const isSameState = (stored: Value[], state: Value[]) => {
@@ -1197,19 +1399,35 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1197
1399
  }
1198
1400
  return true;
1199
1401
  };
1402
+ const getSlot = (hash: number) => (Math.imul(hash, 0x9e3779b1) >>> seen.shift) << 1;
1200
1403
  const findStateIndex = (hash: number, state: Value[]) => {
1201
- const bucket = buckets.get(hash);
1202
- if (bucket === undefined) return -1;
1203
- if (typeof bucket === "number") {
1204
- return isSameState(fingerprintStates[bucket], state) ? bucket : -1;
1404
+ const mask = seen.slots.length - 1;
1405
+ for (let slot = getSlot(hash); ; slot = (slot + 2) & mask) {
1406
+ const entry = seen.slots[slot + 1];
1407
+ if (entry === 0) return -1;
1408
+ if (seen.slots[slot] === hash && isSameState(fingerprintStates[entry - 1], state)) {
1409
+ return entry - 1;
1410
+ }
1205
1411
  }
1206
- return bucket.find((index) => isSameState(fingerprintStates[index], state)) ?? -1;
1412
+ };
1413
+ const insertSeen = (hash: number, entry: number) => {
1414
+ const mask = seen.slots.length - 1;
1415
+ let slot = getSlot(hash);
1416
+ while (seen.slots[slot + 1] !== 0) slot = (slot + 2) & mask;
1417
+ seen.slots[slot] = hash;
1418
+ seen.slots[slot + 1] = entry;
1207
1419
  };
1208
1420
  const markSeen = (hash: number, index: number) => {
1209
- const bucket = buckets.get(hash);
1210
- if (bucket === undefined) buckets.set(hash, index);
1211
- else if (typeof bucket === "number") buckets.set(hash, [bucket, index]);
1212
- else bucket.push(index);
1421
+ seen.size++;
1422
+ if (seen.size * 4 > seen.slots.length) {
1423
+ const slots = seen.slots;
1424
+ seen.slots = new Int32Array(slots.length * 2);
1425
+ seen.shift--;
1426
+ for (let slot = 0; slot < slots.length; slot += 2) {
1427
+ if (slots[slot + 1] !== 0) insertSeen(slots[slot], slots[slot + 1]);
1428
+ }
1429
+ }
1430
+ insertSeen(hash, index + 1);
1213
1431
  };
1214
1432
  const countDistinctState = (depth: number) => {
1215
1433
  runtime.distinctStates = states.length + 1;
@@ -1235,6 +1453,7 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1235
1453
  isExpanding: false,
1236
1454
  candidate: undefined as Value[] | undefined,
1237
1455
  candidateLevel: 0,
1456
+ isFingerprinting: false,
1238
1457
  livenessSource: -1,
1239
1458
  };
1240
1459
  const getPath = (index: number): Value[][] =>
@@ -1321,8 +1540,10 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1321
1540
  current.candidate = successor.state;
1322
1541
  current.candidateLevel = depths[index] + 1;
1323
1542
  if (isCanonicalizedFirst) canonicalizeState(successor.state);
1543
+ current.isFingerprinting = true;
1324
1544
  const fingerprintState = getFingerprintState(successor.state);
1325
1545
  const hash = getStateHash(fingerprintState);
1546
+ current.isFingerprinting = false;
1326
1547
  const found = findStateIndex(hash, fingerprintState);
1327
1548
  const isStateInModel = search.satisfiesConstraints(successor.state, state);
1328
1549
  if (isStateInModel) search.trackStatePossible(successor.state);
@@ -1394,10 +1615,22 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1394
1615
  spec.scope,
1395
1616
  );
1396
1617
  } catch (error) {
1397
- return toFailure(error, []);
1618
+ if (!(error instanceof TlaIllegalStateError))
1619
+ return replayInitialStates(toFailure(error, []));
1620
+ // TLC prints an illegal initial state with null for each variable it leaves undefined, and
1621
+ // stops before it prints the statistics.
1622
+ const illegal = toFailure(
1623
+ error,
1624
+ [],
1625
+ error.state.map((value) => value ?? createModelValue("null")),
1626
+ );
1627
+ return {
1628
+ ...illegal,
1629
+ failure: illegal.failure && { ...illegal.failure, isWithoutStatistics: true },
1630
+ };
1398
1631
  }
1399
1632
  }
1400
- if (outcome.result) return outcome.result;
1633
+ if (outcome.result) return replayInitialStates(outcome.result);
1401
1634
 
1402
1635
  const next = spec.next;
1403
1636
  if (next === undefined) {
@@ -1453,7 +1686,10 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1453
1686
  try {
1454
1687
  outcome.result = visitSuccessor(index, successor, liveSuccessors, source, action);
1455
1688
  } catch (error) {
1456
- outcome.result = toFailure(error, getTrace(index, successor));
1689
+ // TLC reports a successor it cannot fingerprint as a failure of the state it expands.
1690
+ if (current.isFingerprinting) throw error;
1691
+ const failure = toFailure(error, getTrace(index, successor));
1692
+ outcome.result = isStackOverflow(error) ? failure : replaySuccessors(failure, index);
1457
1693
  }
1458
1694
  return outcome.result !== undefined;
1459
1695
  });
@@ -1476,9 +1712,44 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1476
1712
  trace: toTrace(steps, accepted),
1477
1713
  });
1478
1714
  } catch (error) {
1479
- return toFailure(error, getStateTrace(index), undefined, getPartialOutDegrees());
1715
+ return replayFailure(
1716
+ toFailure(toNextStateError(error), getStateTrace(index), undefined, getPartialOutDegrees()),
1717
+ (_, traced) =>
1718
+ createLivenessChecker(
1719
+ search.properties.liveness,
1720
+ spec.temporals,
1721
+ traced,
1722
+ liveGraph,
1723
+ )?.addState(index, state, liveSuccessors),
1724
+ true,
1725
+ );
1480
1726
  }
1481
1727
  };
1728
+ // TLC names the action when the next-state relation has more than one, and prints the
1729
+ // incomplete successor with null for each variable it leaves undefined.
1730
+ const reportIncompleteSuccessor = (error: TlaIncompleteStateError, index: number) => {
1731
+ nextActions.value ??= getNextActions(config, environment, specification.instanceActions);
1732
+ const actions = nextActions.value;
1733
+ const action =
1734
+ actions.length === 1 ? actions[0] : actions.find((item) => item.name === error.action);
1735
+ const variables = `variable${error.missing.length > 1 ? "s are" : " is"} not defined: ${error.missing.join(", ")}.\n`;
1736
+ runtime.generatedStates++;
1737
+ return toFailure(
1738
+ actions.length === 1
1739
+ ? error
1740
+ : new TlaEvaluationError(
1741
+ `Successor state is not completely specified by action ${error.action} of the next-state relation. The following ${variables}`,
1742
+ ),
1743
+ [
1744
+ ...getStateTrace(index),
1745
+ {
1746
+ action: error.action,
1747
+ label: action && getActionLabel(action),
1748
+ state: toRecord(error.state.map((value) => value ?? createModelValue("null"))),
1749
+ },
1750
+ ],
1751
+ );
1752
+ };
1482
1753
  // TLC names the properties and the step back into the cycle from the states it prints.
1483
1754
  const reportLasso = (checker: LivenessChecker, lasso: Lasso) => {
1484
1755
  const path = [...lasso.prefix, ...lasso.cycle];
@@ -1524,7 +1795,14 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1524
1795
  try {
1525
1796
  outcome.result = expandState(index);
1526
1797
  } catch (error) {
1527
- outcome.result = toFailure(withNextStateExitCode(error), getStateTrace(index));
1798
+ const failure =
1799
+ error instanceof TlaIncompleteStateError
1800
+ ? reportIncompleteSuccessor(error, index)
1801
+ : toFailure(toNextStateError(error), getStateTrace(index));
1802
+ outcome.result =
1803
+ error instanceof TlaIncompleteStateError || isStackOverflow(error)
1804
+ ? failure
1805
+ : replaySuccessors(failure, index);
1528
1806
  }
1529
1807
  if (outcome.result) return outcome.result;
1530
1808
  outDegrees[getOutDegreeBucket()]++;
package/src/codegen.ts CHANGED
@@ -10,6 +10,8 @@ import {
10
10
  getSubsetOperator,
11
11
  getEvaluator,
12
12
  getFieldError,
13
+ getNonFunctionError,
14
+ getNonRecordError,
13
15
  isClosedConstant,
14
16
  isTlcInteger,
15
17
  isValueArgument,
@@ -250,12 +252,13 @@ const generateExpression = (generator: Generator, expression: Expression, frame:
250
252
  case "FunctionApplication": {
251
253
  keepLazy(expression.function);
252
254
  const functionCode = generate(expression.function);
255
+ const describeNonFunction = addReference(generator, getNonFunctionError(expression));
253
256
  if (expression.args.length === 1)
254
- return `apply(${functionCode}, ${generate(expression.args[0])})`;
255
- return `apply(${functionCode}, tuple([${expression.args.map((arg) => generate(arg)).join(", ")}]))`;
257
+ return `apply(${functionCode}, ${generate(expression.args[0])}, undefined, ${describeNonFunction})`;
258
+ return `apply(${functionCode}, tuple([${expression.args.map((arg) => generate(arg)).join(", ")}]), undefined, ${describeNonFunction})`;
256
259
  }
257
260
  case "FieldAccess":
258
- return `apply(${generate(expression.record)}, ${JSON.stringify(expression.field)}, ${addReference(generator, getFieldError(expression))})`;
261
+ return `apply(${generate(expression.record)}, ${JSON.stringify(expression.field)}, ${addReference(generator, getFieldError(expression))}, ${addReference(generator, getNonRecordError(expression))})`;
259
262
  case "Record": {
260
263
  const fields = getSortedFields(expression.fields);
261
264
  if (hasDuplicateFields(fields)) return generateDelegate(generator, expression, frame);