tla-ts 0.0.3-dev.31e0776 → 0.0.3-dev.3504663
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/dist/index.cjs +1 -1
- package/dist/index.d.cts +50 -22
- package/dist/index.d.ts +50 -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 +14 -12
- package/dist/run-cli.js +22 -20
- package/dist/transfer.cjs +38 -21
- package/dist/transfer.js +38 -21
- package/package.json +1 -1
- package/src/ast.ts +11 -1
- package/src/builtins.ts +9 -3
- package/src/check.ts +357 -79
- package/src/codegen.ts +6 -3
- package/src/config.ts +224 -170
- package/src/environment.ts +90 -40
- package/src/errors.ts +89 -1
- package/src/evaluate.ts +182 -26
- package/src/exit-codes.ts +22 -3
- package/src/fingerprints.ts +2 -1
- package/src/instances.ts +1 -1
- package/src/levels.ts +173 -37
- package/src/live-check.ts +132 -70
- package/src/liveness.ts +117 -22
- package/src/parallel-worker.ts +2 -2
- package/src/parallel.ts +2 -2
- package/src/parser.ts +71 -19
- package/src/resolve.ts +429 -52
- package/src/run-cli.ts +59 -11
- package/src/sany-lexer.ts +615 -0
- package/src/sany-parse-error.ts +3143 -0
- package/src/spec-description.ts +1 -2
- package/src/standard-modules.ts +54 -45
- package/src/subexpressions.ts +25 -13
- package/src/substitution-levels.ts +38 -17
- package/src/successors.ts +121 -34
- package/src/symmetry.ts +16 -6
- package/src/tableau.ts +51 -24
- package/src/tlc-module.ts +6 -6
- 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 +222 -57
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,
|
|
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
|
|
280
|
-
|
|
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
|
|
379
|
-
|
|
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
|
-
|
|
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({
|
|
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
|
|
781
|
-
const
|
|
782
|
-
|
|
783
|
-
|
|
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
|
-
|
|
818
|
-
|
|
819
|
-
|
|
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
|
-
|
|
855
|
-
constraint.expression,
|
|
856
|
-
|
|
857
|
-
|
|
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
|
-
|
|
902
|
-
|
|
903
|
-
|
|
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 (
|
|
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
|
|
976
|
-
|
|
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
|
-
|
|
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
|
|
1202
|
-
|
|
1203
|
-
|
|
1204
|
-
|
|
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
|
-
|
|
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
|
-
|
|
1210
|
-
if (
|
|
1211
|
-
|
|
1212
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
|
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
|
-
|
|
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);
|