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.
- package/README.md +5 -1
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +70 -22
- package/dist/index.d.ts +70 -22
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +2 -2
- package/dist/parallel.cjs +1 -1
- package/dist/parallel.js +2 -2
- package/dist/run-cli.cjs +20 -18
- package/dist/run-cli.js +22 -20
- package/dist/transfer.cjs +41 -15
- package/dist/transfer.js +41 -15
- package/package.json +1 -1
- package/src/ast.ts +121 -4
- package/src/builtins.ts +9 -3
- package/src/check.ts +480 -106
- package/src/cli-options.ts +11 -5
- package/src/codegen.ts +15 -22
- package/src/config.ts +224 -170
- package/src/dependencies.ts +2 -2
- package/src/environment.ts +410 -130
- package/src/errors.ts +104 -3
- package/src/evaluate.ts +402 -182
- package/src/exit-codes.ts +21 -14
- package/src/fingerprints.ts +2 -1
- package/src/instances.ts +17 -16
- package/src/levels.ts +185 -44
- package/src/live-check.ts +132 -70
- package/src/liveness.ts +118 -24
- package/src/parallel-worker.ts +2 -2
- package/src/parallel.ts +5 -2
- package/src/parser.ts +172 -53
- package/src/resolve.ts +1378 -420
- package/src/run-cli.ts +106 -18
- package/src/runtime.ts +2 -0
- package/src/sany-lexer.ts +615 -0
- package/src/sany-parse-error.ts +3143 -0
- package/src/spec-description.ts +19 -8
- package/src/standard-modules.ts +54 -45
- package/src/standard-ranges.ts +116 -0
- package/src/state-graph.ts +157 -0
- package/src/subexpressions.ts +231 -171
- package/src/substitution-levels.ts +38 -17
- package/src/successors.ts +177 -37
- package/src/symmetry.ts +109 -41
- package/src/tableau.ts +51 -24
- package/src/tlc-ext.ts +29 -12
- package/src/tlc-module.ts +14 -33
- package/src/tlc-modules.ts +4 -0
- package/src/tlc-order.ts +8 -4
- package/src/tlc-random.ts +9 -6
- package/src/tlc-summary.ts +20 -5
- package/src/value-sources.ts +29 -0
- package/src/values.ts +242 -61
package/src/check.ts
CHANGED
|
@@ -1,25 +1,34 @@
|
|
|
1
|
-
import
|
|
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,
|
|
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,
|
|
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
|
|
265
|
-
|
|
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
|
|
364
|
-
|
|
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
|
-
|
|
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({
|
|
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
|
-
|
|
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 ?
|
|
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
|
|
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
|
|
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
|
|
764
|
-
const
|
|
765
|
-
|
|
766
|
-
|
|
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
|
|
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
|
-
|
|
801
|
-
|
|
802
|
-
|
|
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(
|
|
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
|
-
|
|
835
|
-
constraint.expression,
|
|
836
|
-
|
|
837
|
-
|
|
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
|
-
|
|
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 (
|
|
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
|
|
944
|
-
|
|
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
|
-
|
|
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
|
|
1165
|
-
|
|
1166
|
-
|
|
1167
|
-
|
|
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
|
-
|
|
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
|
-
|
|
1173
|
-
if (
|
|
1174
|
-
|
|
1175
|
-
|
|
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 = (
|
|
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
|
-
|
|
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
|
|
1351
|
-
|
|
1352
|
-
|
|
1353
|
-
|
|
1354
|
-
(
|
|
1355
|
-
|
|
1356
|
-
|
|
1357
|
-
|
|
1358
|
-
|
|
1359
|
-
|
|
1360
|
-
|
|
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
|
|
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
|
-
|
|
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()]++;
|