tla-ts 0.0.3-dev.c949d82 → 0.0.3-dev.cfd469d
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 +27 -0
- package/dist/index.d.ts +27 -0
- 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 -13
- package/dist/run-cli.js +22 -21
- package/dist/transfer.cjs +27 -18
- package/dist/transfer.js +27 -18
- package/package.json +1 -1
- package/src/ast.ts +25 -4
- package/src/builtins.ts +9 -3
- package/src/check.ts +210 -40
- package/src/environment.ts +208 -69
- package/src/errors.ts +47 -3
- package/src/evaluate.ts +131 -9
- package/src/fingerprints.ts +2 -1
- package/src/instances.ts +1 -1
- package/src/levels.ts +177 -36
- package/src/liveness.ts +5 -1
- package/src/parser.ts +140 -42
- package/src/resolve.ts +962 -391
- package/src/run-cli.ts +34 -3
- package/src/sany-lexer.ts +615 -0
- package/src/sany-parse-error.ts +3143 -0
- package/src/standard-modules.ts +52 -38
- package/src/standard-ranges.ts +116 -0
- package/src/subexpressions.ts +26 -14
- package/src/substitution-levels.ts +38 -17
- package/src/successors.ts +87 -17
- package/src/value-sources.ts +29 -0
- package/src/values.ts +122 -42
package/package.json
CHANGED
package/src/ast.ts
CHANGED
|
@@ -33,9 +33,12 @@ export interface StringExpression {
|
|
|
33
33
|
location: SourceLocation;
|
|
34
34
|
}
|
|
35
35
|
|
|
36
|
+
// selectorRanges holds the range of each part of a name such as foo!lab, where SANY reports an
|
|
37
|
+
// error in selecting that part.
|
|
36
38
|
export interface IdentifierExpression {
|
|
37
39
|
kind: "Identifier";
|
|
38
40
|
name: string;
|
|
41
|
+
selectorRanges?: SourceRange[];
|
|
39
42
|
location: SourceLocation;
|
|
40
43
|
resolution?: LocalResolution;
|
|
41
44
|
}
|
|
@@ -49,6 +52,7 @@ export interface ApplyExpression {
|
|
|
49
52
|
argumentCounts?: number[];
|
|
50
53
|
// The range of the parenthesized arguments of a named operator, where SANY reports their count.
|
|
51
54
|
argumentsRange?: SourceRange;
|
|
55
|
+
selectorRanges?: SourceRange[];
|
|
52
56
|
location: SourceLocation;
|
|
53
57
|
resolution?: LocalResolution;
|
|
54
58
|
}
|
|
@@ -62,6 +66,7 @@ export interface OperatorReferenceExpression {
|
|
|
62
66
|
export interface LambdaExpression {
|
|
63
67
|
kind: "Lambda";
|
|
64
68
|
params: string[];
|
|
69
|
+
paramRanges?: SourceRange[];
|
|
65
70
|
body: Expression;
|
|
66
71
|
location: SourceLocation;
|
|
67
72
|
}
|
|
@@ -119,7 +124,10 @@ export interface LetExpression {
|
|
|
119
124
|
location: SourceLocation;
|
|
120
125
|
}
|
|
121
126
|
|
|
122
|
-
|
|
127
|
+
// ranges holds the range of each name the pattern binds.
|
|
128
|
+
export type BoundPattern =
|
|
129
|
+
| { kind: "Name"; name: string; ranges?: SourceRange[] }
|
|
130
|
+
| { kind: "Tuple"; names: string[]; ranges?: SourceRange[] };
|
|
123
131
|
|
|
124
132
|
export interface Bound {
|
|
125
133
|
pattern: BoundPattern;
|
|
@@ -137,6 +145,7 @@ export interface UnboundedQuantifierExpression {
|
|
|
137
145
|
kind: "UnboundedQuantifier";
|
|
138
146
|
quantifier: "Forall" | "Exists";
|
|
139
147
|
names: string[];
|
|
148
|
+
nameRanges?: SourceRange[];
|
|
140
149
|
isTemporal?: boolean;
|
|
141
150
|
body: Expression;
|
|
142
151
|
location: SourceLocation;
|
|
@@ -194,6 +203,7 @@ export interface FunctionSetExpression {
|
|
|
194
203
|
export interface RecordField {
|
|
195
204
|
name: string;
|
|
196
205
|
value: Expression;
|
|
206
|
+
location: SourceLocation;
|
|
197
207
|
}
|
|
198
208
|
|
|
199
209
|
export interface RecordExpression {
|
|
@@ -282,6 +292,7 @@ export type Selector =
|
|
|
282
292
|
export interface SubexpressionExpression {
|
|
283
293
|
kind: "Subexpression";
|
|
284
294
|
selectors: Selector[];
|
|
295
|
+
selectorRanges?: SourceRange[];
|
|
285
296
|
location: SourceLocation;
|
|
286
297
|
}
|
|
287
298
|
|
|
@@ -365,6 +376,7 @@ export interface Assumption {
|
|
|
365
376
|
|
|
366
377
|
export interface InstanceSubstitution {
|
|
367
378
|
name: string;
|
|
379
|
+
nameRange: SourceRange;
|
|
368
380
|
expression: Expression;
|
|
369
381
|
}
|
|
370
382
|
|
|
@@ -386,6 +398,7 @@ export interface NewSymbol {
|
|
|
386
398
|
arity: number;
|
|
387
399
|
level: "Constant" | "Variable" | "State" | "Action" | "Temporal";
|
|
388
400
|
set: Expression | undefined;
|
|
401
|
+
nameRange?: SourceRange;
|
|
389
402
|
location: SourceLocation;
|
|
390
403
|
}
|
|
391
404
|
|
|
@@ -437,19 +450,27 @@ export type StepBody =
|
|
|
437
450
|
| Instance
|
|
438
451
|
| DefineStep
|
|
439
452
|
| { kind: "Have"; expression: Expression }
|
|
440
|
-
| { kind: "Take"; names: string[]; bounds: Bound[] }
|
|
453
|
+
| { kind: "Take"; names: string[]; nameRanges?: SourceRange[]; bounds: Bound[] }
|
|
441
454
|
| { kind: "Witness"; expressions: Expression[] }
|
|
442
|
-
| {
|
|
455
|
+
| {
|
|
456
|
+
kind: "Pick";
|
|
457
|
+
names: string[];
|
|
458
|
+
nameRanges?: SourceRange[];
|
|
459
|
+
bounds: Bound[];
|
|
460
|
+
body: Expression;
|
|
461
|
+
}
|
|
443
462
|
| { kind: "Case"; expression: Expression }
|
|
444
463
|
| { kind: "Assert"; isSuffices: boolean; statement: Expression | AssumeProve }
|
|
445
464
|
| { kind: "Qed" };
|
|
446
465
|
|
|
447
|
-
// head is the range of the step number and its statement, without the proof
|
|
466
|
+
// head is the range of the step number and its statement, without the proof, and statement is the
|
|
467
|
+
// range of the statement alone.
|
|
448
468
|
export interface ProofStep {
|
|
449
469
|
name: string | undefined;
|
|
450
470
|
token: string;
|
|
451
471
|
body: StepBody;
|
|
452
472
|
head: SourceRange;
|
|
473
|
+
statement: SourceRange;
|
|
453
474
|
proof: Proof | undefined;
|
|
454
475
|
location: SourceLocation;
|
|
455
476
|
}
|
package/src/builtins.ts
CHANGED
|
@@ -297,15 +297,21 @@ export const getJavaInteger = (value: Value, signature: string) => {
|
|
|
297
297
|
return value;
|
|
298
298
|
};
|
|
299
299
|
|
|
300
|
-
export const
|
|
301
|
-
|
|
300
|
+
export const getArithmeticSignature = (
|
|
301
|
+
javaClass: "Naturals" | "Integers",
|
|
302
|
+
method: string,
|
|
303
|
+
result: string,
|
|
304
|
+
arity: number,
|
|
305
|
+
) =>
|
|
306
|
+
`public static tlc2.value.impl.${result} tlc2.module.${javaClass}.${method}(${Array.from({ length: arity }, () => "tlc2.value.impl.IntValue").join(",")})`;
|
|
302
307
|
|
|
303
308
|
export const defineArithmetic = (
|
|
309
|
+
javaClass: "Naturals" | "Integers",
|
|
304
310
|
name: string,
|
|
305
311
|
method: string,
|
|
306
312
|
compute: (left: number, right: number) => number,
|
|
307
313
|
) => {
|
|
308
|
-
const signature =
|
|
314
|
+
const signature = getArithmeticSignature(javaClass, method, "IntValue", 2);
|
|
309
315
|
return defineBinary(name, (left, right) => {
|
|
310
316
|
const leftNumber = getJavaInteger(left, signature);
|
|
311
317
|
const rightNumber = getJavaInteger(right, signature);
|
package/src/check.ts
CHANGED
|
@@ -16,6 +16,7 @@ import {
|
|
|
16
16
|
STACK_OVERFLOW,
|
|
17
17
|
TlaConfigError,
|
|
18
18
|
TlaEvaluationError,
|
|
19
|
+
TlaIllegalStateError,
|
|
19
20
|
TlaIncompleteStateError,
|
|
20
21
|
TlaModuleError,
|
|
21
22
|
UNEXPECTED_EXCEPTION,
|
|
@@ -35,6 +36,7 @@ import {
|
|
|
35
36
|
import {
|
|
36
37
|
createLivenessChecker,
|
|
37
38
|
type Lasso,
|
|
39
|
+
type LiveGraph,
|
|
38
40
|
type LivenessChecker,
|
|
39
41
|
type LiveSuccessor,
|
|
40
42
|
} from "./live-check";
|
|
@@ -67,8 +69,10 @@ import { createTlcFingerprinter, getTlcFingerprint } from "./tlc-random";
|
|
|
67
69
|
import { createCanonicalizer } from "./canonical";
|
|
68
70
|
import { getPossibleCounts, type CheckerRuntime } from "./runtime";
|
|
69
71
|
import { createCounterExample } from "./tlc-ext";
|
|
72
|
+
import { getFingerprintTrace, valueSources } from "./value-sources";
|
|
70
73
|
import { getFingerprintDistance, OUT_DEGREE_BUCKETS } from "./tlc-summary";
|
|
71
74
|
import {
|
|
75
|
+
assertFingerprintable,
|
|
72
76
|
combineHash,
|
|
73
77
|
createModelValue,
|
|
74
78
|
formatState,
|
|
@@ -140,6 +144,25 @@ export interface EvaluationFailure {
|
|
|
140
144
|
trace: TraceStep[];
|
|
141
145
|
initialState: Record<string, Value> | undefined;
|
|
142
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;
|
|
143
166
|
}
|
|
144
167
|
|
|
145
168
|
export interface CheckResult {
|
|
@@ -915,8 +938,8 @@ export const createSearch = (
|
|
|
915
938
|
const withNextStateExitCode = (error: unknown) =>
|
|
916
939
|
error instanceof TlaModuleError ? setExitCode(error, error.exitCode) : error;
|
|
917
940
|
|
|
918
|
-
// TLC reports a failure of the next-state relation
|
|
919
|
-
// module raised it as an EvalException.
|
|
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.
|
|
920
943
|
const toNextStateError = (error: unknown) =>
|
|
921
944
|
error instanceof TlaEvaluationError &&
|
|
922
945
|
!(error instanceof TlaModuleError) &&
|
|
@@ -927,6 +950,47 @@ const toNextStateError = (error: unknown) =>
|
|
|
927
950
|
)
|
|
928
951
|
: withNextStateExitCode(error);
|
|
929
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
|
+
|
|
930
994
|
const withHeadline = (error: unknown, headline: string) =>
|
|
931
995
|
error instanceof TlaEvaluationError
|
|
932
996
|
? setExitCode(
|
|
@@ -955,9 +1019,10 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
955
1019
|
const onPrint = options.onPrint ?? console.log;
|
|
956
1020
|
// TLC prints again while it rebuilds a trace, between the states it prints. Printing those lines
|
|
957
1021
|
// before the trace would misplace them, so rebuilding a trace prints nothing.
|
|
958
|
-
const output = { isMuted: false };
|
|
1022
|
+
const output = { isMuted: false, replayed: undefined as string[] | undefined };
|
|
959
1023
|
const print = (text: string) => {
|
|
960
|
-
if (
|
|
1024
|
+
if (output.replayed) output.replayed.push(text);
|
|
1025
|
+
else if (!output.isMuted) onPrint(text);
|
|
961
1026
|
};
|
|
962
1027
|
const withoutOutput = <Result>(rebuild: () => Result) => {
|
|
963
1028
|
output.isMuted = true;
|
|
@@ -1019,9 +1084,9 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1019
1084
|
),
|
|
1020
1085
|
});
|
|
1021
1086
|
|
|
1022
|
-
const
|
|
1023
|
-
getTlcDeclarationOrder(options.source, options.loadModule, "variable")
|
|
1024
|
-
);
|
|
1087
|
+
const getVariableOrder = () =>
|
|
1088
|
+
getTlcDeclarationOrder(options.source, options.loadModule, "variable");
|
|
1089
|
+
const search = createSearch(config, environment, getVariableOrder);
|
|
1025
1090
|
const assumptionViolation = findAssumptionViolation(specification.assumptions, environment);
|
|
1026
1091
|
if (assumptionViolation) return createResult("assumption-violation", assumptionViolation);
|
|
1027
1092
|
if (!search) return createSuccess();
|
|
@@ -1045,37 +1110,114 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1045
1110
|
const spec = search.spec;
|
|
1046
1111
|
const getFingerprintState = search.getFingerprintState;
|
|
1047
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
|
+
});
|
|
1048
1191
|
const isReducing = config.view !== undefined || config.symmetry !== undefined;
|
|
1049
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
|
+
};
|
|
1050
1219
|
const liveness = withLivenessExitCode(() =>
|
|
1051
|
-
createLivenessChecker(search.properties.liveness, spec.temporals, environment,
|
|
1052
|
-
getFingerprint: (index) =>
|
|
1053
|
-
(tlcFingerprints[index] ??= Number(
|
|
1054
|
-
BigInt.asIntN(32, runtime.getFingerprint(states[index])),
|
|
1055
|
-
)),
|
|
1056
|
-
getSuccessors: (state) => {
|
|
1057
|
-
const successors: LiveSuccessor[] = [];
|
|
1058
|
-
if (spec.next === undefined) return successors;
|
|
1059
|
-
forEachSuccessor(
|
|
1060
|
-
spec.next,
|
|
1061
|
-
state,
|
|
1062
|
-
environment,
|
|
1063
|
-
(successor) => {
|
|
1064
|
-
canonicalizeState(successor.state);
|
|
1065
|
-
const isInModel =
|
|
1066
|
-
search.satisfiesConstraints(successor.state, state) &&
|
|
1067
|
-
search.satisfiesActionConstraints(state, successor.state);
|
|
1068
|
-
if (!isInModel) return false;
|
|
1069
|
-
const fingerprintState = getFingerprintState(successor.state);
|
|
1070
|
-
const index = findStateIndex(getStateHash(fingerprintState), fingerprintState);
|
|
1071
|
-
successors.push({ index, state: successor.state });
|
|
1072
|
-
return false;
|
|
1073
|
-
},
|
|
1074
|
-
spec.scope,
|
|
1075
|
-
);
|
|
1076
|
-
return successors;
|
|
1077
|
-
},
|
|
1078
|
-
}),
|
|
1220
|
+
createLivenessChecker(search.properties.liveness, spec.temporals, environment, liveGraph),
|
|
1079
1221
|
);
|
|
1080
1222
|
const isCanonicalizedFirst = search.isSymmetric || liveness !== undefined;
|
|
1081
1223
|
|
|
@@ -1248,6 +1390,7 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1248
1390
|
let hash = 0x811c9dc5;
|
|
1249
1391
|
for (let index = 0; index < state.length; index++)
|
|
1250
1392
|
hash = combineHash(hash, getValueHash(state[index]));
|
|
1393
|
+
assertFingerprintable(state);
|
|
1251
1394
|
return hash & 0x3fffffff;
|
|
1252
1395
|
};
|
|
1253
1396
|
const isSameState = (stored: Value[], state: Value[]) => {
|
|
@@ -1472,10 +1615,22 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1472
1615
|
spec.scope,
|
|
1473
1616
|
);
|
|
1474
1617
|
} catch (error) {
|
|
1475
|
-
|
|
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
|
+
};
|
|
1476
1631
|
}
|
|
1477
1632
|
}
|
|
1478
|
-
if (outcome.result) return outcome.result;
|
|
1633
|
+
if (outcome.result) return replayInitialStates(outcome.result);
|
|
1479
1634
|
|
|
1480
1635
|
const next = spec.next;
|
|
1481
1636
|
if (next === undefined) {
|
|
@@ -1533,7 +1688,8 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1533
1688
|
} catch (error) {
|
|
1534
1689
|
// TLC reports a successor it cannot fingerprint as a failure of the state it expands.
|
|
1535
1690
|
if (current.isFingerprinting) throw error;
|
|
1536
|
-
|
|
1691
|
+
const failure = toFailure(error, getTrace(index, successor));
|
|
1692
|
+
outcome.result = isStackOverflow(error) ? failure : replaySuccessors(failure, index);
|
|
1537
1693
|
}
|
|
1538
1694
|
return outcome.result !== undefined;
|
|
1539
1695
|
});
|
|
@@ -1556,7 +1712,17 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1556
1712
|
trace: toTrace(steps, accepted),
|
|
1557
1713
|
});
|
|
1558
1714
|
} catch (error) {
|
|
1559
|
-
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
|
+
);
|
|
1560
1726
|
}
|
|
1561
1727
|
};
|
|
1562
1728
|
// TLC names the action when the next-state relation has more than one, and prints the
|
|
@@ -1629,10 +1795,14 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1629
1795
|
try {
|
|
1630
1796
|
outcome.result = expandState(index);
|
|
1631
1797
|
} catch (error) {
|
|
1632
|
-
|
|
1798
|
+
const failure =
|
|
1633
1799
|
error instanceof TlaIncompleteStateError
|
|
1634
1800
|
? reportIncompleteSuccessor(error, index)
|
|
1635
1801
|
: toFailure(toNextStateError(error), getStateTrace(index));
|
|
1802
|
+
outcome.result =
|
|
1803
|
+
error instanceof TlaIncompleteStateError || isStackOverflow(error)
|
|
1804
|
+
? failure
|
|
1805
|
+
: replaySuccessors(failure, index);
|
|
1636
1806
|
}
|
|
1637
1807
|
if (outcome.result) return outcome.result;
|
|
1638
1808
|
outDegrees[getOutDegreeBucket()]++;
|