tla-ts 0.0.3-dev.07eab97 → 0.0.3-dev.0ad0249
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/cli.cjs +1 -1
- package/dist/cli.js +1 -1
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +160 -46
- package/dist/index.d.ts +160 -46
- 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 +1351 -22
- package/dist/run-cli.js +1351 -22
- package/dist/transfer.cjs +83 -33
- package/dist/transfer.js +83 -33
- package/package.json +4 -1
- package/src/ast.ts +42 -5
- package/src/bags.ts +4 -7
- package/src/builtins.ts +29 -17
- package/src/bundled-modules.ts +3 -3
- package/src/canonical.ts +4 -3
- package/src/check.ts +1296 -429
- package/src/cli.ts +8 -1
- package/src/codegen.ts +68 -21
- package/src/config.ts +225 -206
- package/src/environment.ts +388 -115
- package/src/errors.ts +155 -18
- package/src/evaluate.ts +713 -259
- package/src/exit-codes.ts +6 -24
- package/src/fingerprints.ts +1 -2
- package/src/index.ts +1 -0
- package/src/instances.ts +3 -1
- package/src/java-overrides.ts +104 -25
- package/src/levels.ts +37 -27
- package/src/lexer.ts +14 -1
- package/src/live-check.ts +204 -148
- package/src/liveness.ts +191 -122
- package/src/obligation-expression.ts +2 -2
- package/src/obligation-source.ts +2 -0
- package/src/parallel-worker.ts +6 -1
- package/src/parallel.ts +57 -6
- package/src/parser.ts +369 -115
- package/src/pcal-ast.ts +770 -0
- package/src/pcal-parse.ts +1523 -0
- package/src/pcal-tokenize.ts +516 -0
- package/src/pcal-translate.ts +1230 -0
- package/src/pcal-validate.ts +454 -0
- package/src/randomization.ts +24 -7
- package/src/resolve.ts +1332 -453
- package/src/run-cli.ts +1161 -196
- package/src/runtime.ts +16 -0
- package/src/sany-builtins.ts +147 -0
- package/src/sany-generator.ts +3112 -0
- package/src/sany-levels.ts +1208 -0
- package/src/sany-lexer.ts +545 -0
- package/src/sany-linter.ts +122 -0
- package/src/sany-modules.ts +1398 -0
- package/src/sany-nodes.ts +463 -0
- package/src/sany-parse-error.ts +2161 -0
- package/src/sany-report.ts +354 -0
- package/src/sany-selectors.ts +738 -0
- package/src/sany-source.ts +248 -0
- package/src/sany-xml.ts +1017 -0
- package/src/spec-description.ts +25 -5
- package/src/standard-modules.ts +172 -129
- package/src/standard-ranges.ts +116 -0
- package/src/state-graph.ts +29 -6
- package/src/subexpressions.ts +221 -161
- package/src/successors.ts +141 -173
- package/src/symmetry.ts +168 -50
- package/src/tableau.ts +3 -1
- package/src/tlc-ext.ts +13 -17
- package/src/tlc-messages.ts +329 -0
- package/src/tlc-module.ts +49 -21
- package/src/tlc-modules.ts +0 -4
- package/src/tlc-order.ts +55 -9
- package/src/tlc-random.ts +28 -3
- package/src/tlc-replay.ts +655 -0
- package/src/tlc-version.ts +18 -0
- package/src/transfer.ts +15 -3
- package/src/values.ts +664 -317
package/src/check.ts
CHANGED
|
@@ -12,31 +12,37 @@ import { createEnvironment } from "./environment";
|
|
|
12
12
|
import {
|
|
13
13
|
getErrorExitCode,
|
|
14
14
|
isStackOverflow,
|
|
15
|
-
formatRange,
|
|
16
|
-
STACK_OVERFLOW,
|
|
17
15
|
TlaConfigError,
|
|
18
16
|
TlaEvaluationError,
|
|
19
17
|
TlaIllegalStateError,
|
|
20
|
-
|
|
18
|
+
TlaIncompleteSuccessorError,
|
|
21
19
|
TlaModuleError,
|
|
20
|
+
TlaStackOverflowError,
|
|
21
|
+
getUnexpectedException,
|
|
22
22
|
UNEXPECTED_EXCEPTION,
|
|
23
23
|
} from "./errors";
|
|
24
|
-
import {
|
|
24
|
+
import type { JavaOverride } from "./java-overrides";
|
|
25
|
+
import { EXIT_STATUS, getExitCode, setExitCode, withLivenessExitCode } from "./exit-codes";
|
|
25
26
|
import {
|
|
27
|
+
describeNode,
|
|
26
28
|
describeRange,
|
|
29
|
+
createTracingEnvironment,
|
|
27
30
|
evaluate,
|
|
31
|
+
evaluateStartupDefinitions,
|
|
28
32
|
expectBoolean,
|
|
33
|
+
formatRange,
|
|
29
34
|
getDefinition,
|
|
30
35
|
isConstantLevel,
|
|
31
36
|
isImpure,
|
|
37
|
+
type CallStack,
|
|
32
38
|
type Context,
|
|
33
39
|
type Environment,
|
|
40
|
+
type FingerprintFailure,
|
|
34
41
|
type Scope,
|
|
35
42
|
} from "./evaluate";
|
|
36
43
|
import {
|
|
37
44
|
createLivenessChecker,
|
|
38
45
|
type Lasso,
|
|
39
|
-
type LiveGraph,
|
|
40
46
|
type LivenessChecker,
|
|
41
47
|
type LiveSuccessor,
|
|
42
48
|
} from "./live-check";
|
|
@@ -53,8 +59,10 @@ import {
|
|
|
53
59
|
import {
|
|
54
60
|
getActionLabel,
|
|
55
61
|
getActionSignature,
|
|
62
|
+
getInitActions,
|
|
56
63
|
getNextActions,
|
|
57
64
|
getSpecificationValue,
|
|
65
|
+
toActionValue,
|
|
58
66
|
type SpecAction,
|
|
59
67
|
} from "./spec-description";
|
|
60
68
|
import {
|
|
@@ -64,24 +72,35 @@ import {
|
|
|
64
72
|
type StateWriter,
|
|
65
73
|
} from "./state-graph";
|
|
66
74
|
import { getRepresentative, getSymmetryGroup } from "./symmetry";
|
|
67
|
-
import { getTlcStringOrder,
|
|
75
|
+
import { getTlcStringOrder, getTlcVariableOrder } from "./tlc-order";
|
|
76
|
+
import {
|
|
77
|
+
formatNestedMessage,
|
|
78
|
+
getCodedMessage,
|
|
79
|
+
isEvalException,
|
|
80
|
+
MESSAGE_CODE,
|
|
81
|
+
MISSING_INIT_174,
|
|
82
|
+
} from "./tlc-messages";
|
|
83
|
+
import { replayInitialStates, replaySuccessors } from "./tlc-replay";
|
|
68
84
|
import { createTlcFingerprinter, getTlcFingerprint } from "./tlc-random";
|
|
69
85
|
import { createCanonicalizer } from "./canonical";
|
|
70
86
|
import { getPossibleCounts, type CheckerRuntime } from "./runtime";
|
|
71
|
-
import { createCounterExample } from "./tlc-ext";
|
|
72
|
-
import { getFingerprintTrace, valueSources } from "./value-sources";
|
|
87
|
+
import { createActionRecord, createCounterExample } from "./tlc-ext";
|
|
73
88
|
import { getFingerprintDistance, OUT_DEGREE_BUCKETS } from "./tlc-summary";
|
|
89
|
+
import type { TlcVersion } from "./tlc-version";
|
|
74
90
|
import {
|
|
75
|
-
assertFingerprintable,
|
|
76
91
|
combineHash,
|
|
77
92
|
createModelValue,
|
|
78
93
|
formatState,
|
|
79
94
|
formatValue,
|
|
95
|
+
getHeldValues,
|
|
96
|
+
getFingerprintError,
|
|
97
|
+
markFingerprinted,
|
|
80
98
|
getValueHash,
|
|
81
99
|
isFunctionValue,
|
|
82
100
|
isSameValue,
|
|
83
101
|
isUpdatedElementOf,
|
|
84
102
|
setStringOrder,
|
|
103
|
+
setValueVersion,
|
|
85
104
|
toFiniteFunction,
|
|
86
105
|
type Value,
|
|
87
106
|
} from "./values";
|
|
@@ -101,8 +120,71 @@ export interface CheckOptions {
|
|
|
101
120
|
livenessCheck?: "default" | "final";
|
|
102
121
|
// TLC's -dump: writes the reachable states, or with `dot` the state graph, through writeFile.
|
|
103
122
|
dump?: StateDump;
|
|
123
|
+
// TLC's -tool, which changes the messages of TLC's errors.
|
|
124
|
+
isTool?: boolean;
|
|
125
|
+
// Whether TLC records a binary trace for its trace exploration spec, for which it loads Integers.
|
|
126
|
+
isTraceRecorded?: boolean;
|
|
127
|
+
// Whether the caller printed SANY's report, its warnings included, before the check.
|
|
128
|
+
isSanyReported?: boolean;
|
|
129
|
+
// False for TLC's -nowarning, which changes how TLC computes the successors of some actions.
|
|
130
|
+
isWarningEnabled?: boolean;
|
|
131
|
+
// The TLC whose output tla-ts reproduces, which changes how TLC labels an action.
|
|
132
|
+
version?: TlcVersion;
|
|
133
|
+
// Reports the points of the search at which TLC prints a message.
|
|
134
|
+
onProgress?: (progress: CheckProgress) => void;
|
|
135
|
+
}
|
|
136
|
+
|
|
137
|
+
export interface InitialStatesProgress {
|
|
138
|
+
kind: "initial-states-progress";
|
|
139
|
+
count: number;
|
|
104
140
|
}
|
|
105
141
|
|
|
142
|
+
// A check that TLC's DoInitFunctor reports as violated before it stops its replay of the initial
|
|
143
|
+
// states.
|
|
144
|
+
export interface InitialStateViolation {
|
|
145
|
+
kind: "initial-state-violation";
|
|
146
|
+
status: "invariant-violation" | "liveness-violation";
|
|
147
|
+
name: string;
|
|
148
|
+
state: Record<string, Value>;
|
|
149
|
+
}
|
|
150
|
+
|
|
151
|
+
// A line the spec prints, or what TLC reports as it replays the initial states.
|
|
152
|
+
export type OutputLine = string | InitialStatesProgress | InitialStateViolation;
|
|
153
|
+
|
|
154
|
+
// The spec is parsed, TLC warns about each invariant that is a true constant formula and each
|
|
155
|
+
// property that is a state formula, finds the branches of the temporal properties, computes the
|
|
156
|
+
// initial states, reporting each time their count reaches a power of two, reports how far the
|
|
157
|
+
// search got 3 seconds after it starts and every minute after, and checks the temporal properties
|
|
158
|
+
// on the state graph so far at those times and on the complete state graph at the end.
|
|
159
|
+
export type CheckProgress =
|
|
160
|
+
| { kind: "parsed" }
|
|
161
|
+
| { kind: "constant-level-invariant"; name: string }
|
|
162
|
+
| { kind: "state-level-property"; name: string }
|
|
163
|
+
| { kind: "liveness-initializing"; isSymmetric: boolean; isConstrained: boolean }
|
|
164
|
+
| { kind: "liveness-prepared"; branches: number }
|
|
165
|
+
| { kind: "initial-states-started" }
|
|
166
|
+
| InitialStatesProgress
|
|
167
|
+
| { kind: "initial-states-computed"; initialStates: InitialStates }
|
|
168
|
+
| { kind: "progress"; statistics: SearchStatistics }
|
|
169
|
+
| {
|
|
170
|
+
kind: "liveness-started";
|
|
171
|
+
branches: number;
|
|
172
|
+
// Whether TLC checks the complete state graph, and how many states of it each branch has.
|
|
173
|
+
isComplete: boolean;
|
|
174
|
+
states: number;
|
|
175
|
+
statistics: SearchStatistics;
|
|
176
|
+
}
|
|
177
|
+
| { kind: "liveness-finished" }
|
|
178
|
+
// A warning TLC prints as it evaluates the spec, with its message code.
|
|
179
|
+
| { kind: "warning"; code: number; text: string }
|
|
180
|
+
// A method of the class named after a module, which TLC reports as it loads the class.
|
|
181
|
+
| ({ kind: "java-override" } & JavaOverride);
|
|
182
|
+
|
|
183
|
+
export interface SearchStatistics extends Pick<
|
|
184
|
+
CheckResult,
|
|
185
|
+
"generatedStates" | "distinctStates" | "queuedStates" | "depth"
|
|
186
|
+
> {}
|
|
187
|
+
|
|
106
188
|
export type CheckStatus =
|
|
107
189
|
| "success"
|
|
108
190
|
| "assumption-violation"
|
|
@@ -118,6 +200,9 @@ export interface TraceStep {
|
|
|
118
200
|
// TLC's name, parameters and location for the action that took this step.
|
|
119
201
|
label: string | undefined;
|
|
120
202
|
state: Record<string, Value>;
|
|
203
|
+
// What the spec prints, before TLC prints this step, as TLC evaluates it again to rebuild the
|
|
204
|
+
// trace. The first step has what TLC prints before the trace.
|
|
205
|
+
output?: OutputLine[];
|
|
121
206
|
}
|
|
122
207
|
|
|
123
208
|
export interface Violation {
|
|
@@ -125,44 +210,64 @@ export interface Violation {
|
|
|
125
210
|
// Every temporal property that a liveness counterexample violates, in the configuration's order.
|
|
126
211
|
properties?: string[];
|
|
127
212
|
trace: TraceStep[];
|
|
213
|
+
// What the spec prints after TLC prints the states of the trace, as TLC finds the step back into
|
|
214
|
+
// the cycle of a lasso or rebuilds the trace once more.
|
|
215
|
+
traceOutput?: OutputLine[];
|
|
128
216
|
loopStart: number | undefined;
|
|
129
217
|
loopLabel?: string;
|
|
130
218
|
message?: string;
|
|
131
219
|
counts?: string;
|
|
132
220
|
unwitnessed?: Postcondition;
|
|
221
|
+
// A POSTCONDITION that is false or fails after the counterexample, which TLC checks as it
|
|
222
|
+
// prints one.
|
|
223
|
+
postcondition?: Postcondition;
|
|
224
|
+
// What TLC warns about after a counterexample, with its code.
|
|
225
|
+
warning?: { code: number; text: string };
|
|
133
226
|
}
|
|
134
227
|
|
|
135
228
|
interface Postcondition {
|
|
136
229
|
name: string;
|
|
230
|
+
// TLC's message code.
|
|
231
|
+
code: number;
|
|
137
232
|
message: string;
|
|
138
233
|
counts?: string;
|
|
139
234
|
}
|
|
140
235
|
|
|
141
236
|
// An evaluation that failed during the search, with the behavior up to the state TLC was working on.
|
|
142
237
|
export interface EvaluationFailure {
|
|
238
|
+
// TLC's code for the message, and its text with and without -tool.
|
|
239
|
+
code: number;
|
|
143
240
|
message: string;
|
|
241
|
+
toolMessage: string;
|
|
144
242
|
trace: TraceStep[];
|
|
243
|
+
traceOutput?: OutputLine[];
|
|
145
244
|
initialState: Record<string, Value> | undefined;
|
|
146
245
|
exitCode: number;
|
|
147
|
-
|
|
246
|
+
// The expressions TLC was evaluating when the failure occurred, outermost first, when TLC finds
|
|
247
|
+
// them by replaying the failure.
|
|
248
|
+
callStack: Expression[] | undefined;
|
|
249
|
+
// Whether TLC prints the call stack before the error, as it does for a failed liveness check.
|
|
250
|
+
isCallStackFirst?: boolean;
|
|
251
|
+
// The FingerprintException the replay raises, which TLC reports in place of the call stack.
|
|
252
|
+
fingerprint?: FingerprintFailure;
|
|
253
|
+
// How TLC reports failing again as it prints the trace, since it can't fingerprint the state the
|
|
254
|
+
// failure occurred in.
|
|
255
|
+
traceFailure?: FailureMessage;
|
|
256
|
+
// A POSTCONDITION that is false or fails after the trace, which TLC checks as it prints one.
|
|
257
|
+
postcondition?: Postcondition;
|
|
258
|
+
// Whether TLC stops before it prints the statistics, as it does for an illegal initial state.
|
|
148
259
|
isWithoutStatistics?: boolean;
|
|
149
260
|
}
|
|
150
261
|
|
|
151
|
-
// TLC
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
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;
|
|
262
|
+
// Where TLC's replay of a failure fails.
|
|
263
|
+
interface ReplayFailure {
|
|
264
|
+
callStack: Expression[];
|
|
265
|
+
fingerprint: FingerprintFailure | undefined;
|
|
159
266
|
}
|
|
160
267
|
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
sources: string[];
|
|
165
|
-
reason: string;
|
|
268
|
+
export interface InitialStates {
|
|
269
|
+
generated: number;
|
|
270
|
+
distinct: number;
|
|
166
271
|
}
|
|
167
272
|
|
|
168
273
|
export interface CheckResult {
|
|
@@ -173,14 +278,55 @@ export interface CheckResult {
|
|
|
173
278
|
distinctStates: number;
|
|
174
279
|
queuedStates: number;
|
|
175
280
|
depth: number;
|
|
281
|
+
// How many initial states TLC generated and how many of them were distinct, once it computed
|
|
282
|
+
// them all without a violation or an error.
|
|
283
|
+
initialStates: InitialStates | undefined;
|
|
176
284
|
// How many states that TLC counts as expanded found each number of new states, when TLC prints
|
|
177
285
|
// the outdegree of the state graph.
|
|
178
286
|
outDegrees: number[] | undefined;
|
|
179
287
|
// The smallest distance between the fingerprints of two distinct states, when TLC estimates a
|
|
180
288
|
// collision from the actual fingerprints.
|
|
181
289
|
fingerprintDistance: bigint | undefined;
|
|
290
|
+
// A temporal property TLC finds violated as it adds a deadlocked state to the behavior graph,
|
|
291
|
+
// which it reports after the deadlock.
|
|
292
|
+
additionalViolation?: Violation;
|
|
293
|
+
// Where TLC's worker fails to add the state to the behavior graph after it reports a violation.
|
|
294
|
+
liveCallStack?: Expression[];
|
|
295
|
+
// How many states that TLC counts as expanded found each number of new states, when its workers
|
|
296
|
+
// stop on a violation without an error code, which TLC 1.7.4 reports as a successful search.
|
|
297
|
+
violationOutDegrees?: number[];
|
|
298
|
+
}
|
|
299
|
+
|
|
300
|
+
interface Behavior {
|
|
301
|
+
trace: TraceStep[];
|
|
302
|
+
traceOutput?: OutputLine[];
|
|
303
|
+
}
|
|
304
|
+
|
|
305
|
+
interface TraceOptions {
|
|
306
|
+
loopStart?: number;
|
|
307
|
+
known?: number;
|
|
308
|
+
}
|
|
309
|
+
|
|
310
|
+
interface FailureOptions {
|
|
311
|
+
initialState?: Value[];
|
|
312
|
+
isInitial?: boolean;
|
|
313
|
+
outDegrees?: number[];
|
|
314
|
+
callStack?: Expression[];
|
|
315
|
+
fingerprint?: FingerprintFailure;
|
|
316
|
+
isNextState?: boolean;
|
|
317
|
+
isCallStackFirst?: boolean;
|
|
318
|
+
traceFailure?: FailureMessage;
|
|
319
|
+
// Whether the call stack is of adding the state to the behavior graph, which TLC prints instead
|
|
320
|
+
// of replaying the error.
|
|
321
|
+
isLiveCallStack?: boolean;
|
|
182
322
|
}
|
|
183
323
|
|
|
324
|
+
// TLC prints what the spec prints as it replays a failure after the trace.
|
|
325
|
+
const appendTraceOutput = <Traced extends Behavior>(behavior: Traced, lines: OutputLine[]) => ({
|
|
326
|
+
...behavior,
|
|
327
|
+
traceOutput: [...(behavior.traceOutput ?? []), ...lines],
|
|
328
|
+
});
|
|
329
|
+
|
|
184
330
|
interface NamedExpression {
|
|
185
331
|
name: string;
|
|
186
332
|
expression: Expression;
|
|
@@ -190,6 +336,8 @@ interface NamedExpression {
|
|
|
190
336
|
interface StateCheck extends NamedExpression {
|
|
191
337
|
variables: number[] | undefined;
|
|
192
338
|
membership: Membership | undefined;
|
|
339
|
+
// The whole predicate that TLC evaluates for the check, of which the expression is a conjunct.
|
|
340
|
+
predicate: Expression;
|
|
193
341
|
}
|
|
194
342
|
|
|
195
343
|
// A conjunct `x \in S` whose S reads no variables.
|
|
@@ -258,14 +406,6 @@ const getConfigOperator = (kind: string, name: string, environment: Environment)
|
|
|
258
406
|
return definition;
|
|
259
407
|
};
|
|
260
408
|
|
|
261
|
-
const getConfigDefinition = (kind: string, name: string, environment: Environment) => {
|
|
262
|
-
const definition = getConfigOperator(kind, name, environment);
|
|
263
|
-
if (isConstantLevel(definition, environment)) {
|
|
264
|
-
throw new TlaConfigError(`The ${kind} ${name} cannot be a constant.`);
|
|
265
|
-
}
|
|
266
|
-
return definition;
|
|
267
|
-
};
|
|
268
|
-
|
|
269
409
|
// TLC evaluates every constant definition before it reads the configuration. It keeps a literal
|
|
270
410
|
// number or string, and a definition that fails to evaluate, as an operator.
|
|
271
411
|
const getConstantValue = (name: string, definition: Definition, environment: Environment) => {
|
|
@@ -274,20 +414,77 @@ const getConstantValue = (name: string, definition: Definition, environment: Env
|
|
|
274
414
|
try {
|
|
275
415
|
return evaluate(createIdentifier(name), getContext(environment, undefined, undefined));
|
|
276
416
|
} catch (error) {
|
|
417
|
+
// TLC swallows whatever the definition throws, a stack overflow included.
|
|
277
418
|
if (error instanceof TlaEvaluationError || isStackOverflow(error)) return undefined;
|
|
278
419
|
throw error;
|
|
279
420
|
}
|
|
280
421
|
};
|
|
281
422
|
|
|
282
|
-
|
|
423
|
+
// TLC takes for an operator only a definition it hasn't replaced with its value.
|
|
424
|
+
const getConfigDefinition = (kind: string, name: string, environment: Environment) => {
|
|
283
425
|
const definition = getConfigOperator(kind, name, environment);
|
|
284
|
-
|
|
426
|
+
if (getConstantValue(name, definition, environment) !== undefined) {
|
|
427
|
+
throw new TlaConfigError(`The ${kind} ${name} cannot be a constant.`);
|
|
428
|
+
}
|
|
429
|
+
return definition;
|
|
430
|
+
};
|
|
431
|
+
|
|
432
|
+
// TLC also takes a constant that the configuration assigns a value, which must be TRUE.
|
|
433
|
+
const getConfigPredicate = (kind: string, name: string, environment: Environment) => {
|
|
434
|
+
const definition = environment.constants.has(name)
|
|
435
|
+
? undefined
|
|
436
|
+
: getConfigOperator(kind, name, environment);
|
|
437
|
+
const value = definition
|
|
438
|
+
? getConstantValue(name, definition, environment)
|
|
439
|
+
: environment.constants.get(name);
|
|
285
440
|
if (value !== undefined && value !== true) {
|
|
286
441
|
throw new TlaConfigError(`The ${kind} of ${name} is equal to ${formatValue(value)}`);
|
|
287
442
|
}
|
|
288
443
|
return value === undefined ? definition : undefined;
|
|
289
444
|
};
|
|
290
445
|
|
|
446
|
+
// TLC reports how many initial states it has computed each time the count is a power of two.
|
|
447
|
+
export const reportInitialStatesProgress = (
|
|
448
|
+
count: number,
|
|
449
|
+
onProgress: ((progress: InitialStatesProgress) => void) | undefined,
|
|
450
|
+
) => {
|
|
451
|
+
if (count > 1 && (count & (count - 1)) === 0) {
|
|
452
|
+
onProgress?.({ kind: "initial-states-progress", count });
|
|
453
|
+
}
|
|
454
|
+
};
|
|
455
|
+
|
|
456
|
+
// What TLC does once SANY is done: it computes the constant definitions, then warns about each
|
|
457
|
+
// invariant that is a true constant formula, which it doesn't check. TLC prints each distinct
|
|
458
|
+
// warning once.
|
|
459
|
+
export const reportStartup = (
|
|
460
|
+
specification: {
|
|
461
|
+
environment: Environment;
|
|
462
|
+
startupDefinitions: Definition[];
|
|
463
|
+
javaOverrides: JavaOverride[];
|
|
464
|
+
},
|
|
465
|
+
config: ModelConfig,
|
|
466
|
+
onProgress: CheckOptions["onProgress"],
|
|
467
|
+
) => {
|
|
468
|
+
const environment = specification.environment;
|
|
469
|
+
const warned = new Set<string>();
|
|
470
|
+
environment.runtime.warn = (code, text) => {
|
|
471
|
+
if (warned.has(text)) return;
|
|
472
|
+
warned.add(text);
|
|
473
|
+
onProgress?.({ kind: "warning", code, text });
|
|
474
|
+
};
|
|
475
|
+
onProgress?.({ kind: "parsed" });
|
|
476
|
+
// TLC loads the classes of the modules before it computes the constant definitions.
|
|
477
|
+
specification.javaOverrides.forEach((override) =>
|
|
478
|
+
onProgress?.({ kind: "java-override", ...override }),
|
|
479
|
+
);
|
|
480
|
+
evaluateStartupDefinitions(specification.startupDefinitions, environment);
|
|
481
|
+
config.invariants.forEach((name) => {
|
|
482
|
+
if (!getConfigPredicate("invariant", name, environment)) {
|
|
483
|
+
onProgress?.({ kind: "constant-level-invariant", name });
|
|
484
|
+
}
|
|
485
|
+
});
|
|
486
|
+
};
|
|
487
|
+
|
|
291
488
|
const getInvariants = (names: string[], environment: Environment) => {
|
|
292
489
|
const analyzer = createLevelAnalyzer({
|
|
293
490
|
constants: new Set(environment.constants.keys()),
|
|
@@ -360,14 +557,8 @@ const getSpecification = (config: ModelConfig, environment: Environment): Specif
|
|
|
360
557
|
if (config.specification === undefined) {
|
|
361
558
|
const getOperator = (name: string | undefined, description: string) => {
|
|
362
559
|
if (name === undefined) return undefined;
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
// TLC evaluates a literal body later and reports that it is not a boolean.
|
|
366
|
-
const isLiteral = body.kind === "Number" || body.kind === "String";
|
|
367
|
-
if (!isLiteral && getLevel(identifier, undefined, environment) === 0) {
|
|
368
|
-
throw new TlaConfigError(`The ${description} ${name} cannot be a constant.`);
|
|
369
|
-
}
|
|
370
|
-
return identifier;
|
|
560
|
+
getConfigDefinition(description, name, environment);
|
|
561
|
+
return createIdentifier(name);
|
|
371
562
|
};
|
|
372
563
|
return {
|
|
373
564
|
init: getOperator(config.init, "initial predicate"),
|
|
@@ -376,6 +567,11 @@ const getSpecification = (config: ModelConfig, environment: Environment): Specif
|
|
|
376
567
|
temporals: [],
|
|
377
568
|
};
|
|
378
569
|
}
|
|
570
|
+
if (config.init !== undefined || config.next !== undefined) {
|
|
571
|
+
throw new TlaConfigError(
|
|
572
|
+
"The configuration file cannot specify both INIT/NEXT and SPECIFICATION fields.",
|
|
573
|
+
);
|
|
574
|
+
}
|
|
379
575
|
const initConjuncts: ScopedExpression[] = [];
|
|
380
576
|
const nextActions: ScopedExpression[] = [];
|
|
381
577
|
const temporals: ScopedExpression[] = [];
|
|
@@ -405,8 +601,9 @@ const getSpecification = (config: ModelConfig, environment: Environment): Specif
|
|
|
405
601
|
conjunct.kind === "Always" &&
|
|
406
602
|
getLevel(conjunct.expression, item.scope, environment) < ACTION_LEVEL
|
|
407
603
|
) {
|
|
604
|
+
// TLC accepts the spec and fails when it builds the tableau of the temporal formulas.
|
|
408
605
|
throw setExitCode(
|
|
409
|
-
new
|
|
606
|
+
new TlaEvaluationError(
|
|
410
607
|
`TLC cannot handle the temporal formula ${describeRange(conjunct.expression)}`,
|
|
411
608
|
),
|
|
412
609
|
EXIT_STATUS.error,
|
|
@@ -469,7 +666,11 @@ const getSpecification = (config: ModelConfig, environment: Environment): Specif
|
|
|
469
666
|
};
|
|
470
667
|
};
|
|
471
668
|
|
|
472
|
-
const getProperties = (
|
|
669
|
+
const getProperties = (
|
|
670
|
+
config: ModelConfig,
|
|
671
|
+
environment: Environment,
|
|
672
|
+
onProgress: CheckOptions["onProgress"],
|
|
673
|
+
): Properties => {
|
|
473
674
|
const properties: Properties = {
|
|
474
675
|
initialPredicates: [],
|
|
475
676
|
invariants: [],
|
|
@@ -479,12 +680,21 @@ const getProperties = (config: ModelConfig, environment: Environment): Propertie
|
|
|
479
680
|
config.properties.forEach((name) => {
|
|
480
681
|
const definition = getConfigPredicate("property", name, environment);
|
|
481
682
|
if (!definition) return;
|
|
482
|
-
|
|
683
|
+
// TLC checks a property that is a state formula only on the initial states, so it warns about
|
|
684
|
+
// one as it processes the property, before the constraints.
|
|
685
|
+
if (getLevel(definition.body, undefined, environment) === 1) {
|
|
686
|
+
onProgress?.({ kind: "state-level-property", name });
|
|
687
|
+
}
|
|
688
|
+
// TLC 1.7.4 expands a property as it does a specification, so it doesn't unroll one that
|
|
689
|
+
// quantifies over a constant set.
|
|
690
|
+
const isProperty = environment.runtime.version !== "1.7.4";
|
|
691
|
+
expandTemporal(definition.body, undefined, environment, isProperty).forEach((item) => {
|
|
483
692
|
const conjunct = item.expression;
|
|
484
693
|
if (isConstantTrue(item, environment, "property")) return;
|
|
694
|
+
const partName = item.name ?? name;
|
|
485
695
|
if (conjunct.kind === "Always" && conjunct.expression.kind === "BoxAction") {
|
|
486
696
|
properties.actionProperties.push({
|
|
487
|
-
name:
|
|
697
|
+
name: partName,
|
|
488
698
|
box: conjunct.expression,
|
|
489
699
|
action: conjunct.expression.action,
|
|
490
700
|
subscript: conjunct.expression.subscript,
|
|
@@ -496,11 +706,12 @@ const getProperties = (config: ModelConfig, environment: Environment): Propertie
|
|
|
496
706
|
conjunct.kind === "Always" &&
|
|
497
707
|
getLevel(conjunct.expression, item.scope, environment) <= 1
|
|
498
708
|
) {
|
|
499
|
-
// TLC names the invariant
|
|
500
|
-
|
|
709
|
+
// TLC names the invariant by the operator the property asserts always holds, when it
|
|
710
|
+
// applies the operator to no arguments.
|
|
711
|
+
const body = conjunct.expression;
|
|
501
712
|
properties.invariants.push({
|
|
502
|
-
name:
|
|
503
|
-
expression,
|
|
713
|
+
name: body.kind === "Identifier" ? body.name : partName,
|
|
714
|
+
expression: body,
|
|
504
715
|
scope: item.scope,
|
|
505
716
|
});
|
|
506
717
|
return;
|
|
@@ -508,7 +719,7 @@ const getProperties = (config: ModelConfig, environment: Environment): Propertie
|
|
|
508
719
|
const level = getLevel(conjunct, item.scope, environment);
|
|
509
720
|
if (level < ACTION_LEVEL) {
|
|
510
721
|
properties.initialPredicates.push({
|
|
511
|
-
name:
|
|
722
|
+
name: partName,
|
|
512
723
|
expression: conjunct,
|
|
513
724
|
scope: item.scope,
|
|
514
725
|
});
|
|
@@ -568,6 +779,17 @@ const getMembership = (
|
|
|
568
779
|
: undefined;
|
|
569
780
|
};
|
|
570
781
|
|
|
782
|
+
// TLC evaluates the body of an invariant that the configuration names.
|
|
783
|
+
const getPredicate = (expression: Expression, environment: Environment) => {
|
|
784
|
+
if (expression.kind !== "Identifier" || environment.constants.has(expression.name)) {
|
|
785
|
+
return expression;
|
|
786
|
+
}
|
|
787
|
+
const definition = getDefinition(expression.name, environment);
|
|
788
|
+
return definition?.kind === "Operator" && definition.params.length === 0
|
|
789
|
+
? definition.body
|
|
790
|
+
: expression;
|
|
791
|
+
};
|
|
792
|
+
|
|
571
793
|
const getStateChecks = (named: NamedExpression[], environment: Environment): StateCheck[] =>
|
|
572
794
|
named.flatMap((item) =>
|
|
573
795
|
getConjuncts(item.expression, environment).map((expression) => {
|
|
@@ -580,6 +802,7 @@ const getStateChecks = (named: NamedExpression[], environment: Environment): Sta
|
|
|
580
802
|
scope: item.scope,
|
|
581
803
|
variables,
|
|
582
804
|
membership: getMembership(expression, variables, environment),
|
|
805
|
+
predicate: getPredicate(item.expression, environment),
|
|
583
806
|
};
|
|
584
807
|
}),
|
|
585
808
|
);
|
|
@@ -628,7 +851,25 @@ interface Search {
|
|
|
628
851
|
getStoredFingerprints: (states: Value[][], fingerprintStates: Value[][]) => BigInt64Array;
|
|
629
852
|
getTlcOrder: () => number[];
|
|
630
853
|
isSymmetric: boolean;
|
|
854
|
+
// TLC drops a constraint that is a true constant formula.
|
|
855
|
+
isConstrained: boolean;
|
|
631
856
|
findViolatedInvariant: (state: Value[], parent?: Value[]) => StateCheck | undefined;
|
|
857
|
+
// The checks of a state that TLC evaluates when it replays the computation of the initial states
|
|
858
|
+
// or of the successors of a state, with an environment that records the call stack. The first
|
|
859
|
+
// returns the check that stops the replay, and the second false where TLC stops it.
|
|
860
|
+
// TLC fingerprints a replayed state that satisfies the constraints before it checks the rest.
|
|
861
|
+
checkReplayedInitialState: (
|
|
862
|
+
state: Value[],
|
|
863
|
+
tracing: Environment,
|
|
864
|
+
addFingerprint: () => void,
|
|
865
|
+
) => Pick<InitialStateViolation, "status" | "name"> | undefined;
|
|
866
|
+
// Adding the fingerprint of a successor tells whether TLC had not seen it yet.
|
|
867
|
+
checkReplayedSuccessor: (
|
|
868
|
+
state: Value[],
|
|
869
|
+
next: Value[],
|
|
870
|
+
tracing: Environment,
|
|
871
|
+
addFingerprint: () => boolean,
|
|
872
|
+
) => boolean;
|
|
632
873
|
satisfiesConstraints: (state: Value[], parent?: Value[]) => boolean;
|
|
633
874
|
findFailedInitialPredicate: (state: Value[]) => NamedExpression | undefined;
|
|
634
875
|
findViolatedActionProperty: (state: Value[], next: Value[]) => ActionProperty | undefined;
|
|
@@ -636,7 +877,8 @@ interface Search {
|
|
|
636
877
|
trackStatePossible: (state: Value[]) => void;
|
|
637
878
|
trackActionPossible: (state: Value[], next: Value[]) => void;
|
|
638
879
|
findUnwitnessedPossible: () => Postcondition | undefined;
|
|
639
|
-
|
|
880
|
+
// After a counterexample, TLC skips the postconditions when one of them is constant.
|
|
881
|
+
findPostconditionViolation: (isAfterViolation?: boolean) => Postcondition | undefined;
|
|
640
882
|
}
|
|
641
883
|
|
|
642
884
|
const getContext = (
|
|
@@ -662,21 +904,23 @@ const holdsLikeTlc = (
|
|
|
662
904
|
return value;
|
|
663
905
|
};
|
|
664
906
|
|
|
665
|
-
// SANY prints a number by its digits and any other expression by its location.
|
|
666
907
|
const getExpectedBoolean = (expression: Expression, environment: Environment) => {
|
|
667
908
|
const definition =
|
|
668
909
|
expression.kind === "Identifier" ? getDefinition(expression.name, environment) : undefined;
|
|
669
910
|
const body = definition?.kind === "Operator" ? definition.body : expression;
|
|
670
911
|
const range = definition?.kind === "Operator" ? definition.bodyRange : undefined;
|
|
671
|
-
const location =
|
|
672
|
-
body.kind === "Number"
|
|
673
|
-
? (body.text ?? String(body.value))
|
|
674
|
-
: range
|
|
675
|
-
? formatRange(range)
|
|
676
|
-
: describeRange(body);
|
|
912
|
+
const location = range && body.kind !== "Number" ? formatRange(range) : describeNode(body);
|
|
677
913
|
return `TLC expected a boolean value, but did not find one. ${location}`;
|
|
678
914
|
};
|
|
679
915
|
|
|
916
|
+
// TLC evaluates the whole predicate of a check, which fails at a conjunct that isn't a boolean as
|
|
917
|
+
// the conjunction does.
|
|
918
|
+
const holdsAsConjunct = (check: StateCheck, context: Context) =>
|
|
919
|
+
holdsLikeTlc(check.expression, context, (expression, environment) => {
|
|
920
|
+
holdsLikeTlc(check.predicate, context);
|
|
921
|
+
return getExpectedBoolean(expression, environment);
|
|
922
|
+
});
|
|
923
|
+
|
|
680
924
|
const ignorePossible = () => {};
|
|
681
925
|
|
|
682
926
|
const trackPossible = (items: NamedExpression[], runtime: CheckerRuntime, context: Context) =>
|
|
@@ -718,11 +962,16 @@ export const createSearch = (
|
|
|
718
962
|
config: ModelConfig,
|
|
719
963
|
environment: Environment,
|
|
720
964
|
getVariableOrder: () => string[],
|
|
965
|
+
onProgress?: CheckOptions["onProgress"],
|
|
721
966
|
): Search | undefined => {
|
|
722
967
|
const configInvariants = getInvariants(config.invariants, environment);
|
|
723
968
|
const spec = getSpecification(config, environment);
|
|
724
|
-
const properties = getProperties(config, environment);
|
|
969
|
+
const properties = getProperties(config, environment, onProgress);
|
|
725
970
|
const invariants = getStateChecks([...configInvariants, ...properties.invariants], environment);
|
|
971
|
+
// The invariants TLC evaluates, each of which may have several conjuncts among the checks.
|
|
972
|
+
const invariantPredicates = [
|
|
973
|
+
...new Map(invariants.map((invariant) => [invariant.predicate, invariant])).values(),
|
|
974
|
+
];
|
|
726
975
|
const isCheckingBehaviors =
|
|
727
976
|
invariants.length > 0 ||
|
|
728
977
|
properties.actionProperties.length > 0 ||
|
|
@@ -733,7 +982,11 @@ export const createSearch = (
|
|
|
733
982
|
properties.initialPredicates.length > 0 ||
|
|
734
983
|
environment.variables.length > 0)
|
|
735
984
|
) {
|
|
736
|
-
throw new TlaConfigError(
|
|
985
|
+
throw new TlaConfigError(
|
|
986
|
+
environment.runtime.version === "1.7.4"
|
|
987
|
+
? MISSING_INIT_174
|
|
988
|
+
: "The configuration file did not specify the initial state predicate.",
|
|
989
|
+
);
|
|
737
990
|
}
|
|
738
991
|
if (spec.next === undefined && isCheckingBehaviors) {
|
|
739
992
|
throw new TlaConfigError("The configuration file did not specify the next state predicate.");
|
|
@@ -752,7 +1005,9 @@ export const createSearch = (
|
|
|
752
1005
|
const possible = getPossiblePredicates(config.possible, environment);
|
|
753
1006
|
if (environment.variables.length === 0) return undefined;
|
|
754
1007
|
const symmetryGroup =
|
|
755
|
-
config.symmetry === undefined
|
|
1008
|
+
config.symmetry === undefined
|
|
1009
|
+
? undefined
|
|
1010
|
+
: getSymmetryGroup(config.symmetry, environment, config.substitutions);
|
|
756
1011
|
if (config.view !== undefined) getConfigOperator("view function", config.view, environment);
|
|
757
1012
|
const view =
|
|
758
1013
|
config.view === undefined
|
|
@@ -784,14 +1039,12 @@ export const createSearch = (
|
|
|
784
1039
|
.sort((left, right) => getTlcPosition(left) - getTlcPosition(right));
|
|
785
1040
|
return tlcOrder.indices;
|
|
786
1041
|
};
|
|
787
|
-
// A representative in TLC's variable order is the one whose fingerprint TLC reports.
|
|
788
|
-
const order = symmetryGroup.length > 0 ? getTlcOrder() : undefined;
|
|
789
1042
|
const getViewValue = (expression: Expression, state: Value[]) =>
|
|
790
1043
|
evaluate(expression, getContext(environment, state, undefined));
|
|
791
1044
|
const getTlcStateFingerprint = (state: Value[]) => {
|
|
792
1045
|
const indices = getTlcOrder();
|
|
793
1046
|
const representative =
|
|
794
|
-
symmetryGroup
|
|
1047
|
+
symmetryGroup === undefined ? state : getRepresentative(state, symmetryGroup, indices);
|
|
795
1048
|
return getTlcFingerprint(
|
|
796
1049
|
view === undefined
|
|
797
1050
|
? indices.map((index) => representative[index])
|
|
@@ -807,6 +1060,7 @@ export const createSearch = (
|
|
|
807
1060
|
const location = range ? ` at ${formatRange(range)}` : "";
|
|
808
1061
|
return {
|
|
809
1062
|
name: unwitnessed.name,
|
|
1063
|
+
code: MESSAGE_CODE.possibleUnwitnessed,
|
|
810
1064
|
message: `The _POSSIBLE predicate ${unwitnessed.name}${location} was never witnessed.\nOthers may be unwitnessed too; only witnessed predicates appear with a\nnon-zero count in the record printed above.\nSee https://explain.tlapl.us/possible-conditions for additional details.`,
|
|
811
1065
|
counts: prettyPrint(formatValue(getPossibleCounts(runtime), true)),
|
|
812
1066
|
};
|
|
@@ -814,7 +1068,8 @@ export const createSearch = (
|
|
|
814
1068
|
return {
|
|
815
1069
|
properties,
|
|
816
1070
|
spec,
|
|
817
|
-
isSymmetric: symmetryGroup
|
|
1071
|
+
isSymmetric: symmetryGroup !== undefined,
|
|
1072
|
+
isConstrained: constraints.length > 0 || actionConstraints.length > 0,
|
|
818
1073
|
getTlcOrder,
|
|
819
1074
|
getStoredFingerprints: (states, fingerprintStates) => {
|
|
820
1075
|
if (view !== undefined || isFingerprintedLikeTlc) {
|
|
@@ -830,8 +1085,11 @@ export const createSearch = (
|
|
|
830
1085
|
},
|
|
831
1086
|
getFingerprintState: (state) => {
|
|
832
1087
|
if (isFingerprintedLikeTlc) return [String(getTlcStateFingerprint(state))];
|
|
1088
|
+
// A representative in TLC's variable order is the one whose fingerprint TLC reports.
|
|
833
1089
|
const representative =
|
|
834
|
-
symmetryGroup
|
|
1090
|
+
symmetryGroup === undefined
|
|
1091
|
+
? state
|
|
1092
|
+
: getRepresentative(state, symmetryGroup, getTlcOrder());
|
|
835
1093
|
return view === undefined ? representative : [getViewValue(view.expression, representative)];
|
|
836
1094
|
},
|
|
837
1095
|
findViolatedInvariant: (state, parent) =>
|
|
@@ -847,28 +1105,64 @@ export const createSearch = (
|
|
|
847
1105
|
parent[membership.variable],
|
|
848
1106
|
evaluate(membership.set, context),
|
|
849
1107
|
)
|
|
850
|
-
: !
|
|
1108
|
+
: !holdsAsConjunct(invariant, context);
|
|
851
1109
|
} catch (error) {
|
|
852
1110
|
// TLC reports a failure only on a state after the initial states as an invariant failure.
|
|
853
1111
|
if (!parent) throw error;
|
|
854
1112
|
throw withHeadline(
|
|
855
1113
|
setExitCode(error, EXIT_STATUS.safetyEvaluationFailure),
|
|
1114
|
+
MESSAGE_CODE.invariantEvaluationFailed,
|
|
856
1115
|
`Evaluating invariant ${invariant.name} failed.`,
|
|
857
1116
|
);
|
|
858
1117
|
}
|
|
859
1118
|
}),
|
|
1119
|
+
checkReplayedInitialState: (state, tracing, addFingerprint) => {
|
|
1120
|
+
const holdsIn = (expression: Expression, scope: Scope | undefined) =>
|
|
1121
|
+
holdsLikeTlc(expression, getContext(tracing, state, undefined, scope));
|
|
1122
|
+
if (constraints.every((constraint) => holdsIn(constraint.predicate, constraint.scope))) {
|
|
1123
|
+
addFingerprint();
|
|
1124
|
+
}
|
|
1125
|
+
const invariant = invariantPredicates.find((check) => !holdsIn(check.predicate, check.scope));
|
|
1126
|
+
if (invariant) return { status: "invariant-violation", name: invariant.name };
|
|
1127
|
+
const predicate = properties.initialPredicates.find(
|
|
1128
|
+
(check) => !holdsIn(check.expression, check.scope),
|
|
1129
|
+
);
|
|
1130
|
+
return predicate && { status: "liveness-violation", name: predicate.name };
|
|
1131
|
+
},
|
|
1132
|
+
checkReplayedSuccessor: (state, next, tracing, addFingerprint) => {
|
|
1133
|
+
// TLC evaluates the action constraints only on a state that satisfies the constraints.
|
|
1134
|
+
const isInModel =
|
|
1135
|
+
constraints.every((constraint) =>
|
|
1136
|
+
holdsLikeTlc(
|
|
1137
|
+
constraint.predicate,
|
|
1138
|
+
getContext(tracing, next, undefined, constraint.scope),
|
|
1139
|
+
),
|
|
1140
|
+
) &&
|
|
1141
|
+
actionConstraints.every((constraint) =>
|
|
1142
|
+
holdsLikeTlc(constraint.expression, getContext(tracing, state, next, constraint.scope)),
|
|
1143
|
+
);
|
|
1144
|
+
// ModelChecker.doNext checks the invariants of a successor it has not seen, which includes
|
|
1145
|
+
// one outside the model.
|
|
1146
|
+
const isUnseen = isInModel ? addFingerprint() : true;
|
|
1147
|
+
return (
|
|
1148
|
+
(!isUnseen ||
|
|
1149
|
+
invariantPredicates.every((invariant) =>
|
|
1150
|
+
holdsLikeTlc(
|
|
1151
|
+
invariant.predicate,
|
|
1152
|
+
getContext(tracing, next, undefined, invariant.scope),
|
|
1153
|
+
),
|
|
1154
|
+
)) &&
|
|
1155
|
+
actionProperties.every((property) =>
|
|
1156
|
+
holdsLikeTlc(property.box, getContext(tracing, state, next, property.scope)),
|
|
1157
|
+
)
|
|
1158
|
+
);
|
|
1159
|
+
},
|
|
860
1160
|
satisfiesConstraints: (state, parent) =>
|
|
861
|
-
constraints.every(
|
|
862
|
-
|
|
863
|
-
|
|
864
|
-
|
|
865
|
-
|
|
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
|
-
}),
|
|
1161
|
+
constraints.every(
|
|
1162
|
+
(constraint) =>
|
|
1163
|
+
isUnchangedFor(constraint, state, parent) ||
|
|
1164
|
+
holdsAsConjunct(constraint, getContext(environment, state, undefined)),
|
|
1165
|
+
),
|
|
872
1166
|
findFailedInitialPredicate: (state) =>
|
|
873
1167
|
properties.initialPredicates.find(
|
|
874
1168
|
(predicate) =>
|
|
@@ -896,18 +1190,19 @@ export const createSearch = (
|
|
|
896
1190
|
} catch (error) {
|
|
897
1191
|
throw withHeadline(
|
|
898
1192
|
withNextStateExitCode(error),
|
|
1193
|
+
MESSAGE_CODE.actionPropertyEvaluationFailed,
|
|
899
1194
|
`Evaluating action property ${property.name} failed.`,
|
|
900
1195
|
);
|
|
901
1196
|
}
|
|
902
1197
|
}),
|
|
903
1198
|
satisfiesActionConstraints: (state, next) =>
|
|
904
|
-
actionConstraints.every((constraint) =>
|
|
905
|
-
|
|
906
|
-
|
|
907
|
-
|
|
908
|
-
|
|
909
|
-
|
|
910
|
-
|
|
1199
|
+
actionConstraints.every((constraint) =>
|
|
1200
|
+
holdsLikeTlc(
|
|
1201
|
+
constraint.expression,
|
|
1202
|
+
getContext(environment, state, next),
|
|
1203
|
+
(expression) => `${UNEXPECTED_EXCEPTION}${getExpectedBoolean(expression, environment)}`,
|
|
1204
|
+
),
|
|
1205
|
+
),
|
|
911
1206
|
trackStatePossible:
|
|
912
1207
|
statePossible.length === 0
|
|
913
1208
|
? ignorePossible
|
|
@@ -919,14 +1214,40 @@ export const createSearch = (
|
|
|
919
1214
|
: (state, next) =>
|
|
920
1215
|
trackPossible(actionPossible, runtime, getContext(environment, state, next)),
|
|
921
1216
|
findUnwitnessedPossible,
|
|
922
|
-
findPostconditionViolation: () => {
|
|
1217
|
+
findPostconditionViolation: (isAfterViolation = false) => {
|
|
1218
|
+
// TLC replaces a definition it computes when it starts by its value, and then rejects it as
|
|
1219
|
+
// a postcondition before it checks any of them.
|
|
1220
|
+
const constant = config.postconditions.find((name) => {
|
|
1221
|
+
const definition = getDefinition(name, environment);
|
|
1222
|
+
return definition !== undefined && environment.definitionValues.has(definition);
|
|
1223
|
+
});
|
|
1224
|
+
if (constant !== undefined) {
|
|
1225
|
+
if (isAfterViolation) return undefined;
|
|
1226
|
+
throw setExitCode(
|
|
1227
|
+
new TlaEvaluationError(
|
|
1228
|
+
`${UNEXPECTED_EXCEPTION}The post condition ${constant} cannot be a constant.`,
|
|
1229
|
+
),
|
|
1230
|
+
EXIT_STATUS.error,
|
|
1231
|
+
);
|
|
1232
|
+
}
|
|
923
1233
|
const unwitnessed = findUnwitnessedPossible();
|
|
924
1234
|
if (unwitnessed) return unwitnessed;
|
|
925
1235
|
for (const name of config.postconditions) {
|
|
926
1236
|
const failure = getConstantFailure(createIdentifier(name), environment, "a postcondition");
|
|
927
|
-
if (failure)
|
|
928
|
-
|
|
929
|
-
}
|
|
1237
|
+
if (!failure) continue;
|
|
1238
|
+
const range = getBodyRange(name, environment);
|
|
1239
|
+
const location = range ? ` at ${formatRange(range)}` : "";
|
|
1240
|
+
return failure.message === undefined
|
|
1241
|
+
? {
|
|
1242
|
+
name,
|
|
1243
|
+
code: MESSAGE_CODE.postconditionFalse,
|
|
1244
|
+
message: `Postcondition ${name}${location} is false.`,
|
|
1245
|
+
}
|
|
1246
|
+
: {
|
|
1247
|
+
name,
|
|
1248
|
+
code: MESSAGE_CODE.postconditionFailed,
|
|
1249
|
+
message: `Evaluating postcondition ${name}${location} failed.\n${failure.message}`,
|
|
1250
|
+
};
|
|
930
1251
|
}
|
|
931
1252
|
return undefined;
|
|
932
1253
|
},
|
|
@@ -938,99 +1259,179 @@ export const createSearch = (
|
|
|
938
1259
|
const withNextStateExitCode = (error: unknown) =>
|
|
939
1260
|
error instanceof TlaModuleError ? setExitCode(error, error.exitCode) : error;
|
|
940
1261
|
|
|
941
|
-
//
|
|
942
|
-
|
|
943
|
-
|
|
944
|
-
|
|
945
|
-
|
|
946
|
-
|
|
947
|
-
|
|
948
|
-
|
|
949
|
-
|
|
950
|
-
|
|
951
|
-
|
|
952
|
-
|
|
953
|
-
|
|
954
|
-
|
|
955
|
-
|
|
956
|
-
//
|
|
957
|
-
|
|
958
|
-
const
|
|
959
|
-
|
|
960
|
-
|
|
961
|
-
|
|
962
|
-
|
|
963
|
-
|
|
964
|
-
|
|
965
|
-
//
|
|
966
|
-
//
|
|
967
|
-
const
|
|
968
|
-
|
|
969
|
-
|
|
970
|
-
|
|
1262
|
+
// Stops a replay where TLC stops it without a failure, as at a violated invariant.
|
|
1263
|
+
const STOP_REPLAY = new Error("The replay stopped");
|
|
1264
|
+
|
|
1265
|
+
// The codes of the errors in the configuration and the spec that TLC's EC.ExitStatus maps to a
|
|
1266
|
+
// configuration error.
|
|
1267
|
+
const CONFIG_ERROR_CODES = new Set([
|
|
1268
|
+
...Array.from({ length: 24 }, (_, index) => 2222 + index),
|
|
1269
|
+
2272,
|
|
1270
|
+
2273,
|
|
1271
|
+
2274,
|
|
1272
|
+
2280,
|
|
1273
|
+
2281,
|
|
1274
|
+
]);
|
|
1275
|
+
|
|
1276
|
+
// When TLC's replay of the initial states doesn't fail again, it exits with the code of the
|
|
1277
|
+
// TLCRuntimeException it reported.
|
|
1278
|
+
const getInitialExitCode = (error: TlaEvaluationError) => {
|
|
1279
|
+
const coded = getCodedMessage(error.message);
|
|
1280
|
+
return coded && !coded.isEvalException && CONFIG_ERROR_CODES.has(coded.code)
|
|
1281
|
+
? EXIT_STATUS.configParseError
|
|
1282
|
+
: getErrorExitCode(error);
|
|
1283
|
+
};
|
|
1284
|
+
|
|
1285
|
+
// When TLC's replay of an error fails again, an EvalException from a standard module's Java code
|
|
1286
|
+
// decides the exit status, and any other failure exits as a nested expression failure. An error
|
|
1287
|
+
// that heads or wraps another exits as the other.
|
|
1288
|
+
const getReplayExitCode = (error: TlaEvaluationError): number => {
|
|
1289
|
+
const inner = error.cause;
|
|
1290
|
+
if (inner instanceof TlaEvaluationError) return getReplayExitCode(inner);
|
|
1291
|
+
return error instanceof TlaModuleError ? error.exitCode : EXIT_STATUS.specEvaluationFailure;
|
|
1292
|
+
};
|
|
1293
|
+
|
|
1294
|
+
// An error that TLC reports with a message of its own, by that message's code and first line, and
|
|
1295
|
+
// the error whose message follows.
|
|
1296
|
+
interface HeadedError {
|
|
1297
|
+
code: number;
|
|
1298
|
+
headline: string;
|
|
1299
|
+
inner: TlaEvaluationError;
|
|
1300
|
+
}
|
|
1301
|
+
|
|
1302
|
+
const headedErrors = new WeakMap<Error, HeadedError>();
|
|
1303
|
+
|
|
1304
|
+
const withHeadline = (error: unknown, code: number, headline: string) => {
|
|
1305
|
+
if (!(error instanceof TlaEvaluationError)) return error;
|
|
1306
|
+
const headed = setExitCode(
|
|
1307
|
+
new TlaEvaluationError(`${headline}\n${error.message}`, error),
|
|
1308
|
+
getErrorExitCode(error),
|
|
1309
|
+
);
|
|
1310
|
+
headedErrors.set(headed, { code, headline, inner: error });
|
|
1311
|
+
return headed;
|
|
1312
|
+
};
|
|
1313
|
+
|
|
1314
|
+
const UNEXPECTED_HEADLINE = UNEXPECTED_EXCEPTION.slice(0, UNEXPECTED_EXCEPTION.indexOf("\n"));
|
|
1315
|
+
|
|
1316
|
+
// TLC 1.7.4's Worker wraps an error in adding a successor in a RuntimeException, whose message
|
|
1317
|
+
// names the class of the error.
|
|
1318
|
+
const WRAPPED_EVAL_EXCEPTION = `${UNEXPECTED_EXCEPTION}tlc2.tool.EvalException: `;
|
|
1319
|
+
const WRAPPED_RUNTIME_EXCEPTION = `${UNEXPECTED_EXCEPTION}util.Assert$TLCRuntimeException: `;
|
|
1320
|
+
|
|
1321
|
+
const UNEXPECTED_EVAL_EXCEPTION = getUnexpectedException("tlc2.tool.EvalException");
|
|
1322
|
+
|
|
1323
|
+
const getWrappedException = (error: TlaEvaluationError) =>
|
|
1324
|
+
isEvalException(error) ? WRAPPED_EVAL_EXCEPTION : WRAPPED_RUNTIME_EXCEPTION;
|
|
1325
|
+
|
|
1326
|
+
// TLC reports an EvalException, or a TLCRuntimeException without a message of its own, as an
|
|
1327
|
+
// exception it didn't expect.
|
|
1328
|
+
const withUnexpectedException = <Result>(compute: () => Result) => {
|
|
971
1329
|
try {
|
|
972
|
-
|
|
973
|
-
return { callStack: undefined };
|
|
1330
|
+
return compute();
|
|
974
1331
|
} catch (error) {
|
|
975
|
-
if (!(error instanceof TlaEvaluationError))
|
|
976
|
-
|
|
977
|
-
|
|
978
|
-
|
|
979
|
-
|
|
980
|
-
|
|
981
|
-
|
|
982
|
-
|
|
983
|
-
|
|
984
|
-
|
|
985
|
-
|
|
986
|
-
|
|
1332
|
+
if (!(error instanceof TlaEvaluationError)) throw error;
|
|
1333
|
+
if (isEvalException(error)) {
|
|
1334
|
+
throw new TlaEvaluationError(`${UNEXPECTED_EVAL_EXCEPTION}${error.message}`);
|
|
1335
|
+
}
|
|
1336
|
+
if (getCodedMessage(error.message)) throw error;
|
|
1337
|
+
throw new TlaEvaluationError(`${UNEXPECTED_EXCEPTION}${error.message}`);
|
|
1338
|
+
}
|
|
1339
|
+
};
|
|
1340
|
+
|
|
1341
|
+
// The starts of TLC's messages for the exceptions it didn't expect.
|
|
1342
|
+
const UNEXPECTED_EXCEPTIONS = [
|
|
1343
|
+
WRAPPED_EVAL_EXCEPTION,
|
|
1344
|
+
WRAPPED_RUNTIME_EXCEPTION,
|
|
1345
|
+
UNEXPECTED_EXCEPTION,
|
|
1346
|
+
UNEXPECTED_EVAL_EXCEPTION,
|
|
1347
|
+
];
|
|
1348
|
+
|
|
1349
|
+
// The text of an error's message, with the message of a coded error inside it marked in -tool
|
|
1350
|
+
// output as TLC marks it.
|
|
1351
|
+
const formatErrorMessage = (error: TlaEvaluationError, isTool: boolean): string => {
|
|
1352
|
+
const headed = headedErrors.get(error);
|
|
1353
|
+
if (headed) return `${headed.headline}\n${formatErrorMessage(headed.inner, isTool)}`;
|
|
1354
|
+
const message = error.message;
|
|
1355
|
+
const prefix = UNEXPECTED_EXCEPTIONS.find((start) => message.startsWith(start)) ?? "";
|
|
1356
|
+
return `${prefix}${formatNestedMessage(message.slice(prefix.length), isTool)}`;
|
|
1357
|
+
};
|
|
1358
|
+
|
|
1359
|
+
// How TLC reports an error: with the code of its own message for an error that it reports with a
|
|
1360
|
+
// headline; and, when the error escapes the computation of next states, with the code of an
|
|
1361
|
+
// EvalException, or as an unexpected exception for any other error.
|
|
1362
|
+
interface FailureMessage {
|
|
1363
|
+
code: number;
|
|
1364
|
+
message: string;
|
|
1365
|
+
toolMessage: string;
|
|
1366
|
+
}
|
|
1367
|
+
|
|
1368
|
+
const getFailureMessage = (error: TlaEvaluationError, isNextState: boolean): FailureMessage => {
|
|
1369
|
+
const headed = headedErrors.get(error);
|
|
1370
|
+
const message = error.message;
|
|
1371
|
+
if (headed) {
|
|
1372
|
+
return {
|
|
1373
|
+
code: headed.code,
|
|
1374
|
+
message,
|
|
1375
|
+
toolMessage: formatErrorMessage(error, true),
|
|
1376
|
+
};
|
|
1377
|
+
}
|
|
1378
|
+
if (isNextState && isEvalException(error)) {
|
|
987
1379
|
return {
|
|
988
|
-
|
|
989
|
-
|
|
1380
|
+
code: getCodedMessage(message)?.code ?? MESSAGE_CODE.general,
|
|
1381
|
+
message,
|
|
1382
|
+
toolMessage: message,
|
|
990
1383
|
};
|
|
991
1384
|
}
|
|
1385
|
+
const isUnexpected = isNextState && !message.startsWith(UNEXPECTED_HEADLINE);
|
|
1386
|
+
const prefix = isUnexpected ? UNEXPECTED_EXCEPTION : "";
|
|
1387
|
+
return {
|
|
1388
|
+
code: MESSAGE_CODE.general,
|
|
1389
|
+
message: `${prefix}${message}`,
|
|
1390
|
+
toolMessage: `${prefix}${formatErrorMessage(error, true)}`,
|
|
1391
|
+
};
|
|
992
1392
|
};
|
|
993
1393
|
|
|
994
|
-
const withHeadline = (error: unknown, headline: string) =>
|
|
995
|
-
error instanceof TlaEvaluationError
|
|
996
|
-
? setExitCode(
|
|
997
|
-
new TlaEvaluationError(`${headline}\n${error.message}`, error),
|
|
998
|
-
getErrorExitCode(error),
|
|
999
|
-
)
|
|
1000
|
-
: error;
|
|
1001
|
-
|
|
1002
1394
|
// TLC finishes the -dump file whether or not the search finds a violation.
|
|
1003
1395
|
export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
1004
|
-
const stateWriter =
|
|
1396
|
+
const stateWriter =
|
|
1397
|
+
options.dump && createStateWriter(options.dump, options.writeFile, options.version);
|
|
1005
1398
|
try {
|
|
1006
1399
|
return searchStates(options, stateWriter);
|
|
1007
1400
|
} catch (error) {
|
|
1008
|
-
// TLC reports a stack overflow outside the search
|
|
1009
|
-
throw isStackOverflow(error)
|
|
1010
|
-
? setExitCode(new TlaEvaluationError(STACK_OVERFLOW), EXIT_STATUS.error)
|
|
1011
|
-
: error;
|
|
1401
|
+
// TLC reports a stack overflow outside the search on its own, and exits with 255.
|
|
1402
|
+
throw isStackOverflow(error) ? createStackOverflowError() : error;
|
|
1012
1403
|
} finally {
|
|
1013
1404
|
stateWriter?.close();
|
|
1014
1405
|
}
|
|
1015
1406
|
};
|
|
1016
1407
|
|
|
1408
|
+
const createStackOverflowError = () => setExitCode(new TlaStackOverflowError(), EXIT_STATUS.error);
|
|
1409
|
+
|
|
1017
1410
|
const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefined): CheckResult => {
|
|
1018
|
-
const config =
|
|
1411
|
+
const config =
|
|
1412
|
+
typeof options.config === "string"
|
|
1413
|
+
? parseConfig(options.config, options.version)
|
|
1414
|
+
: options.config;
|
|
1019
1415
|
const onPrint = options.onPrint ?? console.log;
|
|
1020
|
-
// TLC prints again while it rebuilds a trace, between the states it prints
|
|
1021
|
-
//
|
|
1022
|
-
const output = {
|
|
1416
|
+
// TLC prints again while it rebuilds a trace, between the states it prints, so rebuilding a trace
|
|
1417
|
+
// keeps what it prints for the trace.
|
|
1418
|
+
const output = { lines: undefined as OutputLine[] | undefined };
|
|
1023
1419
|
const print = (text: string) => {
|
|
1024
|
-
if (output.
|
|
1025
|
-
else
|
|
1420
|
+
if (output.lines) output.lines.push(text);
|
|
1421
|
+
else onPrint(text);
|
|
1026
1422
|
};
|
|
1027
|
-
const
|
|
1028
|
-
|
|
1029
|
-
const
|
|
1030
|
-
output.
|
|
1031
|
-
|
|
1423
|
+
const getOutput = <Result>(rebuild: () => Result) => {
|
|
1424
|
+
const outer = output.lines;
|
|
1425
|
+
const lines: OutputLine[] = [];
|
|
1426
|
+
output.lines = lines;
|
|
1427
|
+
try {
|
|
1428
|
+
return { result: rebuild(), lines };
|
|
1429
|
+
} finally {
|
|
1430
|
+
output.lines = outer;
|
|
1431
|
+
}
|
|
1032
1432
|
};
|
|
1033
1433
|
setStringOrder(getTlcStringOrder(options.source, config, options.loadModule));
|
|
1434
|
+
setValueVersion(options.version);
|
|
1034
1435
|
const specification = createEnvironment(config, {
|
|
1035
1436
|
source: options.source,
|
|
1036
1437
|
loadModule: options.loadModule,
|
|
@@ -1038,9 +1439,16 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1038
1439
|
print,
|
|
1039
1440
|
files: { readFile: options.readFile, writeFile: options.writeFile },
|
|
1040
1441
|
seed: options.seed,
|
|
1442
|
+
isTool: options.isTool,
|
|
1443
|
+
isTraceRecorded: options.isTraceRecorded,
|
|
1444
|
+
isSanyReported: options.isSanyReported,
|
|
1445
|
+
isWarningEnabled: options.isWarningEnabled,
|
|
1446
|
+
version: options.version,
|
|
1041
1447
|
});
|
|
1448
|
+
reportStartup(specification, config, options.onProgress);
|
|
1042
1449
|
const environment = specification.environment;
|
|
1043
1450
|
const runtime = environment.runtime;
|
|
1451
|
+
const is174 = runtime.version === "1.7.4";
|
|
1044
1452
|
runtime.pause = options.onPause ?? (() => {});
|
|
1045
1453
|
runtime.getSpecification = () =>
|
|
1046
1454
|
getSpecificationValue(
|
|
@@ -1049,7 +1457,7 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1049
1457
|
specification.variableLocations,
|
|
1050
1458
|
specification.instanceActions,
|
|
1051
1459
|
);
|
|
1052
|
-
const statistics = { depth: 0 };
|
|
1460
|
+
const statistics = { depth: 0, initialStates: undefined as InitialStates | undefined };
|
|
1053
1461
|
const createResult = (
|
|
1054
1462
|
status: CheckStatus,
|
|
1055
1463
|
violation?: Omit<Violation, "loopStart"> & { loopStart?: number },
|
|
@@ -1062,15 +1470,26 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1062
1470
|
distinctStates: runtime.distinctStates,
|
|
1063
1471
|
queuedStates: runtime.queueSize,
|
|
1064
1472
|
depth: runtime.generatedStates === 0 ? 0 : Math.max(statistics.depth, 1),
|
|
1473
|
+
initialStates: statistics.initialStates,
|
|
1065
1474
|
outDegrees: undefined,
|
|
1066
1475
|
fingerprintDistance: undefined,
|
|
1067
1476
|
});
|
|
1068
1477
|
const outDegrees = Array.from({ length: OUT_DEGREE_BUCKETS }, () => 0);
|
|
1069
1478
|
const expansion = { newStates: 0 };
|
|
1070
1479
|
const getOutDegreeBucket = () => Math.min(expansion.newStates, OUT_DEGREE_BUCKETS - 1);
|
|
1071
|
-
// TLC counts the state it was expanding when an evaluation failed.
|
|
1480
|
+
// TLC counts the state it was expanding when an evaluation failed, except TLC 1.7.4, whose
|
|
1481
|
+
// worker stops before it counts the state.
|
|
1072
1482
|
const getPartialOutDegrees = () =>
|
|
1073
1483
|
outDegrees.map((count, degree) => (degree === getOutDegreeBucket() ? count + 1 : count));
|
|
1484
|
+
const getFailureOutDegrees = () => (is174 ? [...outDegrees] : getPartialOutDegrees());
|
|
1485
|
+
// TLC 1.7.4 doesn't name the properties a counterexample violates, so it evaluates none of them.
|
|
1486
|
+
const getViolatedProperties = (checker: LivenessChecker, path: Value[][], cycleStart: number) =>
|
|
1487
|
+
is174 ? [] : checker.getViolatedProperties(path, cycleStart);
|
|
1488
|
+
// A violation in a successor ends the expansion of a state before TLC counts it.
|
|
1489
|
+
const withOutDegrees = (result: CheckResult, degrees = [...outDegrees]): CheckResult => ({
|
|
1490
|
+
...result,
|
|
1491
|
+
violationOutDegrees: degrees,
|
|
1492
|
+
});
|
|
1074
1493
|
const createSuccess = (): CheckResult => ({
|
|
1075
1494
|
...createResult("success"),
|
|
1076
1495
|
outDegrees: [...outDegrees],
|
|
@@ -1084,141 +1503,235 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1084
1503
|
),
|
|
1085
1504
|
});
|
|
1086
1505
|
|
|
1087
|
-
const
|
|
1088
|
-
|
|
1089
|
-
|
|
1090
|
-
|
|
1091
|
-
|
|
1092
|
-
|
|
1506
|
+
const search = createSearch(
|
|
1507
|
+
config,
|
|
1508
|
+
environment,
|
|
1509
|
+
() => getTlcVariableOrder(options.source, options.loadModule),
|
|
1510
|
+
options.onProgress,
|
|
1511
|
+
);
|
|
1512
|
+
const findViolatedAssumption = () =>
|
|
1513
|
+
findAssumptionViolation(specification.assumptions, environment);
|
|
1514
|
+
if (!search) {
|
|
1515
|
+
runtime.isStarted = true;
|
|
1516
|
+
const assumptionViolation = findViolatedAssumption();
|
|
1517
|
+
if (assumptionViolation) return createResult("assumption-violation", assumptionViolation);
|
|
1518
|
+
// TLC computes the initial states of a spec without variables, of which there are none.
|
|
1519
|
+
statistics.initialStates = { generated: 0, distinct: 0 };
|
|
1520
|
+
options.onProgress?.({ kind: "initial-states-started" });
|
|
1521
|
+
options.onProgress?.({
|
|
1522
|
+
kind: "initial-states-computed",
|
|
1523
|
+
initialStates: statistics.initialStates,
|
|
1524
|
+
});
|
|
1525
|
+
return createSuccess();
|
|
1526
|
+
}
|
|
1093
1527
|
const hasPostconditions = config.postconditions.length > 0 || config.possible.length > 0;
|
|
1094
|
-
|
|
1095
|
-
|
|
1096
|
-
|
|
1097
|
-
|
|
1528
|
+
// The state of each step of a trace without the alias, and the action TLC finds for the step,
|
|
1529
|
+
// which CounterExample records.
|
|
1530
|
+
const traceSteps = new WeakMap<
|
|
1531
|
+
TraceStep,
|
|
1532
|
+
{ state: Record<string, Value>; action: SpecAction | undefined }
|
|
1533
|
+
>();
|
|
1534
|
+
const getStepState = (step: TraceStep) => traceSteps.get(step)?.state ?? step.state;
|
|
1535
|
+
const getStepAction = (step: TraceStep) => {
|
|
1536
|
+
const action = traceSteps.get(step)?.action;
|
|
1537
|
+
return action ? toActionValue(action) : createActionRecord(step.action);
|
|
1538
|
+
};
|
|
1539
|
+
// Worker#printTrace checks the postconditions on the CounterExample of each trace it prints, so
|
|
1540
|
+
// what they print follows the trace.
|
|
1541
|
+
const checkTracePostconditions = (
|
|
1542
|
+
trace: TraceStep[],
|
|
1543
|
+
loop: { start: number; action: Value } | undefined,
|
|
1098
1544
|
) => {
|
|
1099
1545
|
if (hasPostconditions) {
|
|
1100
|
-
const start = violation.loopStart;
|
|
1101
1546
|
runtime.counterExample = createCounterExample(
|
|
1102
|
-
|
|
1103
|
-
|
|
1547
|
+
trace.map(getStepState),
|
|
1548
|
+
trace.slice(1).map(getStepAction),
|
|
1549
|
+
loop,
|
|
1104
1550
|
);
|
|
1105
1551
|
}
|
|
1106
1552
|
const unwitnessed = search.findUnwitnessedPossible();
|
|
1107
|
-
|
|
1108
|
-
|
|
1553
|
+
const checked = unwitnessed
|
|
1554
|
+
? { result: undefined, lines: [] }
|
|
1555
|
+
: getOutput(() => search.findPostconditionViolation(true));
|
|
1556
|
+
return { unwitnessed, postcondition: checked.result, lines: checked.lines };
|
|
1557
|
+
};
|
|
1558
|
+
const reportViolation = (
|
|
1559
|
+
status: CheckStatus,
|
|
1560
|
+
violation: Omit<Violation, "loopStart"> & { loopStart?: number },
|
|
1561
|
+
getLoopAction?: () => Value,
|
|
1562
|
+
) => {
|
|
1563
|
+
const start = violation.loopStart;
|
|
1564
|
+
const checked = checkTracePostconditions(
|
|
1565
|
+
violation.trace,
|
|
1566
|
+
start === undefined || !getLoopAction ? undefined : { start, action: getLoopAction() },
|
|
1567
|
+
);
|
|
1568
|
+
const traceOutput = [...(violation.traceOutput ?? []), ...checked.lines];
|
|
1569
|
+
return createResult(status, {
|
|
1570
|
+
...violation,
|
|
1571
|
+
...(traceOutput.length > 0 && { traceOutput }),
|
|
1572
|
+
...(checked.unwitnessed && { unwitnessed: checked.unwitnessed }),
|
|
1573
|
+
...(checked.postcondition && { postcondition: checked.postcondition }),
|
|
1574
|
+
});
|
|
1109
1575
|
};
|
|
1110
1576
|
const spec = search.spec;
|
|
1111
1577
|
const getFingerprintState = search.getFingerprintState;
|
|
1112
1578
|
const nextActions = { value: undefined as SpecAction[] | undefined };
|
|
1113
|
-
const
|
|
1114
|
-
|
|
1115
|
-
|
|
1116
|
-
|
|
1117
|
-
|
|
1118
|
-
|
|
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) => {
|
|
1579
|
+
const getSpecNextActions = () =>
|
|
1580
|
+
(nextActions.value ??= getNextActions(config, environment, specification.instanceActions));
|
|
1581
|
+
// Where TLC's replay of a failed computation fails, or undefined when the replay completes.
|
|
1582
|
+
const getReplayFailure = (replay: (tracing: Environment) => void): ReplayFailure | undefined => {
|
|
1583
|
+
const tracing = createTracingEnvironment(environment);
|
|
1584
|
+
const callStack = tracing.callStack;
|
|
1137
1585
|
try {
|
|
1138
|
-
|
|
1586
|
+
replay(tracing);
|
|
1587
|
+
return undefined;
|
|
1139
1588
|
} catch (error) {
|
|
1140
|
-
|
|
1589
|
+
// A replay that overflows the stack again has an empty call stack.
|
|
1590
|
+
if (isStackOverflow(error)) return { callStack: [], fingerprint: undefined };
|
|
1591
|
+
if (!(error instanceof TlaEvaluationError) || !callStack) return undefined;
|
|
1592
|
+
return { callStack: callStack.expressions, fingerprint: callStack.fingerprint };
|
|
1593
|
+
}
|
|
1594
|
+
};
|
|
1595
|
+
// The sources of the values a fingerprint fails inside, outermost first: each value fails as it
|
|
1596
|
+
// fingerprints a value it holds.
|
|
1597
|
+
const findFailedSources = (value: Value, sources: CallStack["sources"]): Expression[] => {
|
|
1598
|
+
if (typeof value !== "object") return [];
|
|
1599
|
+
const source = sources.get(value);
|
|
1600
|
+
const failed = getHeldValues(value).find((held) => getFingerprintError(held) !== undefined);
|
|
1601
|
+
return [
|
|
1602
|
+
...(source ? [source] : []),
|
|
1603
|
+
...(failed === undefined ? [] : findFailedSources(failed, sources)),
|
|
1604
|
+
];
|
|
1605
|
+
};
|
|
1606
|
+
// TLC's replay fingerprints the states it finds, and a value the replay built raises a
|
|
1607
|
+
// FingerprintException when it fails to.
|
|
1608
|
+
const fingerprintReplayed = (state: Value[], callStack: CallStack | undefined) => {
|
|
1609
|
+
for (const value of getFingerprintState(state)) {
|
|
1610
|
+
const error = getFingerprintError(value);
|
|
1611
|
+
if (!error) continue;
|
|
1612
|
+
const sources = callStack ? findFailedSources(value, callStack.sources) : [];
|
|
1613
|
+
// TLC fingerprints a state outside any evaluation, so its call stack is empty.
|
|
1614
|
+
if (callStack && sources.length > 0) {
|
|
1615
|
+
callStack.expressions.length = 0;
|
|
1616
|
+
callStack.isFrozen = true;
|
|
1617
|
+
callStack.fingerprint = { sources, reason: error.message };
|
|
1618
|
+
}
|
|
1141
1619
|
throw error;
|
|
1142
1620
|
}
|
|
1621
|
+
state.forEach(markFingerprinted);
|
|
1143
1622
|
};
|
|
1144
|
-
//
|
|
1145
|
-
|
|
1146
|
-
|
|
1147
|
-
|
|
1148
|
-
|
|
1149
|
-
|
|
1150
|
-
|
|
1623
|
+
// The replay adds the states it hasn't seen to TLC's set of states, which already holds the state
|
|
1624
|
+
// that failed after TLC added it.
|
|
1625
|
+
const createReplayedStates = () => {
|
|
1626
|
+
const replayed = unstoredState.fingerprint ? [unstoredState.fingerprint] : [];
|
|
1627
|
+
return (state: Value[], callStack: CallStack | undefined) => {
|
|
1628
|
+
fingerprintReplayed(state, callStack);
|
|
1629
|
+
const fingerprintState = getFingerprintState(state);
|
|
1630
|
+
const isSeen =
|
|
1631
|
+
findStateIndex(getStateHash(fingerprintState), fingerprintState) !== -1 ||
|
|
1632
|
+
replayed.some((seen) => isSameState(seen, fingerprintState));
|
|
1633
|
+
if (isSeen) return false;
|
|
1634
|
+
replayed.push(fingerprintState);
|
|
1635
|
+
runtime.distinctStates++;
|
|
1636
|
+
return true;
|
|
1637
|
+
};
|
|
1638
|
+
};
|
|
1639
|
+
// TLC's DoInitFunctor reports its progress again as it replays the initial states, and adds each
|
|
1640
|
+
// one it hasn't seen to the behavior graph. After a FingerprintException, it only counts the
|
|
1641
|
+
// states left, then throws the exception.
|
|
1642
|
+
const replayInit = () => {
|
|
1643
|
+
const replayed = { count: 0 };
|
|
1644
|
+
const deferred: TlaEvaluationError[] = [];
|
|
1645
|
+
const addReplayed = createReplayedStates();
|
|
1646
|
+
return getReplayFailure((tracing) => {
|
|
1647
|
+
replayInitialStates(
|
|
1648
|
+
getInitActions(config, environment, specification.instanceActions),
|
|
1649
|
+
tracing,
|
|
1151
1650
|
(state) => {
|
|
1152
|
-
|
|
1153
|
-
|
|
1154
|
-
|
|
1155
|
-
|
|
1156
|
-
|
|
1651
|
+
reportInitialStatesProgress(replayed.count, (progress) => output.lines?.push(progress));
|
|
1652
|
+
replayed.count++;
|
|
1653
|
+
runtime.generatedStates = replayed.count;
|
|
1654
|
+
if (deferred.length > 0) return;
|
|
1655
|
+
try {
|
|
1656
|
+
const addFingerprint = () => {
|
|
1657
|
+
if (!addReplayed(state, tracing.callStack)) return;
|
|
1658
|
+
runtime.queueSize++;
|
|
1659
|
+
liveness?.addInitialState(states.length, state, tracing);
|
|
1660
|
+
};
|
|
1661
|
+
const violation = search.checkReplayedInitialState(state, tracing, addFingerprint);
|
|
1662
|
+
if (violation) {
|
|
1663
|
+
const traced = toTrace([{ action: undefined, state }], []).trace[0].state;
|
|
1664
|
+
output.lines?.push({ kind: "initial-state-violation", ...violation, state: traced });
|
|
1665
|
+
throw STOP_REPLAY;
|
|
1666
|
+
}
|
|
1667
|
+
} catch (error) {
|
|
1668
|
+
if (!(error instanceof TlaEvaluationError) || !tracing.callStack?.fingerprint) {
|
|
1669
|
+
throw error;
|
|
1670
|
+
}
|
|
1671
|
+
deferred.push(error);
|
|
1672
|
+
}
|
|
1157
1673
|
},
|
|
1158
|
-
spec.scope,
|
|
1159
1674
|
);
|
|
1675
|
+
if (deferred.length > 0) throw deferred[0];
|
|
1160
1676
|
});
|
|
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
1677
|
};
|
|
1171
|
-
|
|
1172
|
-
|
|
1173
|
-
|
|
1174
|
-
|
|
1175
|
-
|
|
1176
|
-
|
|
1177
|
-
|
|
1178
|
-
|
|
1179
|
-
|
|
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
|
-
);
|
|
1678
|
+
const replayNext = (state: Value[]) =>
|
|
1679
|
+
getReplayFailure((tracing) => {
|
|
1680
|
+
const addReplayed = createReplayedStates();
|
|
1681
|
+
replaySuccessors(getSpecNextActions(), state, tracing, (next) => {
|
|
1682
|
+
const addFingerprint = () => addReplayed(next, tracing.callStack);
|
|
1683
|
+
if (!search.checkReplayedSuccessor(state, next, tracing, addFingerprint)) {
|
|
1684
|
+
throw STOP_REPLAY;
|
|
1685
|
+
}
|
|
1686
|
+
});
|
|
1190
1687
|
});
|
|
1191
1688
|
const isReducing = config.view !== undefined || config.symmetry !== undefined;
|
|
1192
1689
|
const tlcFingerprints: number[] = [];
|
|
1193
|
-
|
|
1194
|
-
|
|
1195
|
-
|
|
1196
|
-
|
|
1197
|
-
|
|
1198
|
-
|
|
1199
|
-
|
|
1200
|
-
|
|
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
|
-
};
|
|
1690
|
+
// TLC warns about the liveness checker before it builds it.
|
|
1691
|
+
if (search.properties.liveness.length > 0) {
|
|
1692
|
+
options.onProgress?.({
|
|
1693
|
+
kind: "liveness-initializing",
|
|
1694
|
+
isSymmetric: search.isSymmetric,
|
|
1695
|
+
isConstrained: search.isConstrained,
|
|
1696
|
+
});
|
|
1697
|
+
}
|
|
1219
1698
|
const liveness = withLivenessExitCode(() =>
|
|
1220
|
-
|
|
1699
|
+
withUnexpectedException(() =>
|
|
1700
|
+
createLivenessChecker(search.properties.liveness, spec.temporals, environment, {
|
|
1701
|
+
getFingerprint: ({ index, state }) =>
|
|
1702
|
+
(tlcFingerprints[index] ??= Number(BigInt.asIntN(32, runtime.getFingerprint(state)))),
|
|
1703
|
+
getSuccessors: (source, state) => {
|
|
1704
|
+
const successors: LiveSuccessor[] = [];
|
|
1705
|
+
if (spec.next === undefined) return successors;
|
|
1706
|
+
// The constraints read the level of the state whose successors they check, as when TLC
|
|
1707
|
+
// explored it.
|
|
1708
|
+
const livenessSource = current.livenessSource;
|
|
1709
|
+
current.livenessSource = source;
|
|
1710
|
+
forEachSuccessor(
|
|
1711
|
+
spec.next,
|
|
1712
|
+
state,
|
|
1713
|
+
environment,
|
|
1714
|
+
(successor) => {
|
|
1715
|
+
canonicalizeState(successor.state);
|
|
1716
|
+
const isInModel =
|
|
1717
|
+
search.satisfiesConstraints(successor.state, state) &&
|
|
1718
|
+
search.satisfiesActionConstraints(state, successor.state);
|
|
1719
|
+
if (!isInModel) return false;
|
|
1720
|
+
const fingerprintState = getFingerprintState(successor.state);
|
|
1721
|
+
const index = findStateIndex(getStateHash(fingerprintState), fingerprintState);
|
|
1722
|
+
successors.push({ index, state: successor.state });
|
|
1723
|
+
return false;
|
|
1724
|
+
},
|
|
1725
|
+
spec.scope,
|
|
1726
|
+
);
|
|
1727
|
+
current.livenessSource = livenessSource;
|
|
1728
|
+
return successors;
|
|
1729
|
+
},
|
|
1730
|
+
}),
|
|
1731
|
+
),
|
|
1221
1732
|
);
|
|
1733
|
+
// TLC 1.7.4 creates its model checker, which TLCGet reads, once it has built the liveness checker.
|
|
1734
|
+
runtime.isStarted = true;
|
|
1222
1735
|
const isCanonicalizedFirst = search.isSymmetric || liveness !== undefined;
|
|
1223
1736
|
|
|
1224
1737
|
const states: Value[][] = [];
|
|
@@ -1258,58 +1771,107 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1258
1771
|
return toAliasRecord(value, fieldOrder) ?? toRecord(state);
|
|
1259
1772
|
} catch (error) {
|
|
1260
1773
|
if (!(error instanceof TlaConfigError || error instanceof TlaEvaluationError)) throw error;
|
|
1261
|
-
return {
|
|
1774
|
+
return {
|
|
1775
|
+
...toRecord(state),
|
|
1776
|
+
_ALIASEvalError: formatNestedMessage(error.message, options.isTool ?? false),
|
|
1777
|
+
};
|
|
1262
1778
|
}
|
|
1263
1779
|
};
|
|
1264
|
-
// TLC
|
|
1265
|
-
// the previous state.
|
|
1266
|
-
|
|
1267
|
-
|
|
1780
|
+
// TLC finds the action of a step as the first action that takes it, evaluated as when the search
|
|
1781
|
+
// expanded the previous state.
|
|
1782
|
+
// TLC finds the action of a successor it holds by the successor's values, and of any other state
|
|
1783
|
+
// by its fingerprint.
|
|
1784
|
+
const findStepAction = (index: number, previous: Value[], state: Value[], isHeld: boolean) => {
|
|
1785
|
+
const actions = getSpecNextActions();
|
|
1268
1786
|
const expanding = { ...current };
|
|
1269
1787
|
Object.assign(current, { index, isExpanding: true, candidate: undefined });
|
|
1270
|
-
const
|
|
1271
|
-
const
|
|
1788
|
+
const getKey = isHeld ? (values: Value[]) => values : getFingerprintState;
|
|
1789
|
+
const key = getKey(state);
|
|
1790
|
+
const action = actions.find((item) =>
|
|
1272
1791
|
getSuccessors(item.expression, previous, environment, item.scope).some((successor) =>
|
|
1273
|
-
isSameState(
|
|
1792
|
+
isSameState(getKey(successor.state), key),
|
|
1274
1793
|
),
|
|
1275
1794
|
);
|
|
1276
1795
|
Object.assign(current, expanding);
|
|
1277
|
-
return action
|
|
1796
|
+
return action;
|
|
1278
1797
|
};
|
|
1279
|
-
|
|
1798
|
+
// Before TLC prints a trace, it rebuilds from the initial predicate the states it does not keep,
|
|
1799
|
+
// all but the last `known` ones. As it prints each later step, it finds the action that takes
|
|
1800
|
+
// the step. Then it rebuilds the trace once more, unless the trace is a liveness counterexample
|
|
1801
|
+
// or TLC is 1.7.4.
|
|
1802
|
+
const toTrace = (
|
|
1803
|
+
steps: Successor[],
|
|
1804
|
+
path: number[],
|
|
1805
|
+
traceOptions: TraceOptions = {},
|
|
1806
|
+
): Behavior => {
|
|
1280
1807
|
const alias = config.alias;
|
|
1281
|
-
const
|
|
1282
|
-
|
|
1283
|
-
|
|
1284
|
-
|
|
1285
|
-
|
|
1286
|
-
|
|
1287
|
-
|
|
1288
|
-
|
|
1289
|
-
|
|
1290
|
-
|
|
1291
|
-
|
|
1292
|
-
|
|
1293
|
-
|
|
1294
|
-
|
|
1295
|
-
|
|
1296
|
-
|
|
1297
|
-
|
|
1298
|
-
|
|
1808
|
+
const known = traceOptions.known ?? 1;
|
|
1809
|
+
// Rebuilding the trace from the initial predicate can reset what TLCSet stored.
|
|
1810
|
+
const initialOutput = steps.length > 1 ? getOutput(getSpecInitialStates).lines : [];
|
|
1811
|
+
// TLC finds the action that takes each step before it evaluates the alias.
|
|
1812
|
+
const found = steps.map((step, position) =>
|
|
1813
|
+
position === 0 || step.action === "Stuttering"
|
|
1814
|
+
? { result: undefined, lines: [] }
|
|
1815
|
+
: getOutput(() =>
|
|
1816
|
+
findStepAction(
|
|
1817
|
+
path[position - 1],
|
|
1818
|
+
steps[position - 1].state,
|
|
1819
|
+
step.state,
|
|
1820
|
+
known === 2 && position === steps.length - 1,
|
|
1821
|
+
),
|
|
1822
|
+
),
|
|
1823
|
+
);
|
|
1824
|
+
const outputs = found.map((step) => step.lines);
|
|
1825
|
+
const loopStart = traceOptions.loopStart;
|
|
1826
|
+
// 1.7.4's LiveWorker#printTrace rebuilds a lasso up to the start of its cycle at once, and then
|
|
1827
|
+
// each state of the cycle as it prints it.
|
|
1828
|
+
const rebuilt = is174 && loopStart !== undefined ? loopStart + 1 : steps.length - known;
|
|
1829
|
+
const prefixOutput = rebuilt > 0 ? [initialOutput, ...outputs.slice(1, rebuilt)].flat() : [];
|
|
1830
|
+
return {
|
|
1831
|
+
trace: steps.map((step, position) => {
|
|
1832
|
+
const action = found[position].result;
|
|
1833
|
+
const traceStep: TraceStep = {
|
|
1834
|
+
action: step.action,
|
|
1835
|
+
label: action && getActionLabel(action, options.version),
|
|
1836
|
+
state:
|
|
1837
|
+
alias === undefined
|
|
1838
|
+
? toRecord(step.state)
|
|
1839
|
+
: getAliasState(alias, steps, position, loopStart),
|
|
1840
|
+
output: position === 0 ? prefixOutput : position < rebuilt ? [] : outputs[position],
|
|
1841
|
+
};
|
|
1842
|
+
if (alias !== undefined || action) {
|
|
1843
|
+
traceSteps.set(traceStep, { state: toRecord(step.state), action });
|
|
1844
|
+
}
|
|
1845
|
+
return traceStep;
|
|
1846
|
+
}),
|
|
1847
|
+
traceOutput: known > 0 && !is174 ? [initialOutput, ...outputs].flat() : [],
|
|
1848
|
+
};
|
|
1299
1849
|
};
|
|
1300
1850
|
const getSpecInitialStates = () =>
|
|
1301
1851
|
spec.init === undefined ? [] : getInitialStates(spec.init, environment, spec.scope);
|
|
1302
|
-
|
|
1303
|
-
|
|
1852
|
+
// TLC's Tool#getState rebuilds a successor action by action, up to the first action that
|
|
1853
|
+
// generates it. A trace keeps what the spec prints as TLC rebuilds it, so finding its states
|
|
1854
|
+
// prints nothing.
|
|
1855
|
+
const findTraceSuccessor = (state: Value[], isMatch: (successor: Successor) => boolean) =>
|
|
1856
|
+
getOutput(() => {
|
|
1857
|
+
for (const action of getSpecNextActions()) {
|
|
1858
|
+
const successor = getSuccessors(action.expression, state, environment, action.scope).find(
|
|
1859
|
+
isMatch,
|
|
1860
|
+
);
|
|
1861
|
+
if (successor) return { ...successor, action: successor.action ?? action.name };
|
|
1862
|
+
}
|
|
1863
|
+
return undefined;
|
|
1864
|
+
}).result;
|
|
1304
1865
|
const hasFingerprint = (state: Value[], index: number) =>
|
|
1305
1866
|
isSameState(getFingerprintState(state), fingerprintStates[index]);
|
|
1306
1867
|
const findSuccessorWithFingerprint = (state: Value[], index: number) =>
|
|
1307
|
-
|
|
1868
|
+
findTraceSuccessor(state, (successor) => hasFingerprint(successor.state, index));
|
|
1308
1869
|
const getPathStates = (path: number[], nextFailure: string) => {
|
|
1309
|
-
const initial =
|
|
1870
|
+
const initial = getOutput(() =>
|
|
1310
1871
|
isReducing || isImpure(environment)
|
|
1311
1872
|
? getSpecInitialStates().find((state) => hasFingerprint(state, path[0]))
|
|
1312
|
-
: states[path[0]]
|
|
1873
|
+
: states[path[0]],
|
|
1874
|
+
).result;
|
|
1313
1875
|
if (!initial) throw new TlaEvaluationError(INITIAL_RECOVERY_FAILURE);
|
|
1314
1876
|
const steps: Successor[] = [{ state: initial, action: undefined }];
|
|
1315
1877
|
for (let position = 1; position < path.length; position++) {
|
|
@@ -1335,46 +1897,119 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1335
1897
|
: path.map((position) => ({ state: states[position], action: actions[position] }));
|
|
1336
1898
|
if (!last) return toTrace(steps, path);
|
|
1337
1899
|
const action = isReducing
|
|
1338
|
-
?
|
|
1339
|
-
|
|
1340
|
-
)?.action
|
|
1900
|
+
? findTraceSuccessor(states[index], (successor) => isSameState(successor.state, last.state))
|
|
1901
|
+
?.action
|
|
1341
1902
|
: last.action;
|
|
1342
|
-
return toTrace([...steps, { state: last.state, action }], path);
|
|
1903
|
+
return toTrace([...steps, { state: last.state, action }], path, { known: 2 });
|
|
1343
1904
|
};
|
|
1344
1905
|
// TLC prints an initial state on its own without evaluating the alias.
|
|
1345
|
-
|
|
1906
|
+
// TLCTrace#getTrace recovers even a lone initial state from the initial predicate, printing
|
|
1907
|
+
// again, though TLC 1.7.4 doesn't.
|
|
1908
|
+
const getStateTrace = (index: number): Behavior =>
|
|
1346
1909
|
parents[index] === -1
|
|
1347
|
-
?
|
|
1910
|
+
? {
|
|
1911
|
+
trace: [{ action: undefined, label: undefined, state: toRecord(states[index]) }],
|
|
1912
|
+
traceOutput: is174 ? [] : getOutput(getSpecInitialStates).lines,
|
|
1913
|
+
}
|
|
1348
1914
|
: getTrace(index);
|
|
1915
|
+
// TLC rebuilds the trace again for the postcondition after it prints a violation, but not after
|
|
1916
|
+
// an evaluation fails.
|
|
1917
|
+
const getFailedTrace = (index: number, successor: Successor): Behavior => ({
|
|
1918
|
+
trace: getTrace(index, successor).trace,
|
|
1919
|
+
});
|
|
1349
1920
|
// TLC names the initial state it was checking unless a standard module's Java code failed.
|
|
1350
|
-
const
|
|
1351
|
-
|
|
1352
|
-
|
|
1353
|
-
|
|
1354
|
-
|
|
1355
|
-
|
|
1356
|
-
|
|
1357
|
-
|
|
1358
|
-
|
|
1359
|
-
return
|
|
1360
|
-
? toFailure(
|
|
1361
|
-
setExitCode(new TlaEvaluationError(STACK_OVERFLOW), EXIT_STATUS.error),
|
|
1362
|
-
getStateTrace(current.index),
|
|
1363
|
-
)
|
|
1364
|
-
: toFailure(new TlaEvaluationError(STACK_OVERFLOW), trace, initialState);
|
|
1921
|
+
const getFailureExitCode = (error: TlaEvaluationError, failureOptions: FailureOptions) => {
|
|
1922
|
+
// TLC 1.7.4 exits with the result of its replay of the initial states, which only fails again
|
|
1923
|
+
// when the error isn't in adding a state it has already seen to the behavior graph.
|
|
1924
|
+
if (
|
|
1925
|
+
failureOptions.isInitial &&
|
|
1926
|
+
!failureOptions.callStack &&
|
|
1927
|
+
!failureOptions.fingerprint &&
|
|
1928
|
+
is174
|
|
1929
|
+
) {
|
|
1930
|
+
return EXIT_STATUS.success;
|
|
1365
1931
|
}
|
|
1932
|
+
if (!failureOptions.callStack) {
|
|
1933
|
+
return failureOptions.isInitial ? getInitialExitCode(error) : getErrorExitCode(error);
|
|
1934
|
+
}
|
|
1935
|
+
if (failureOptions.isCallStackFirst) return getErrorExitCode(error);
|
|
1936
|
+
// Without a replay, TLC exits with the code of the error, as for any error it didn't expect.
|
|
1937
|
+
if (failureOptions.isLiveCallStack) {
|
|
1938
|
+
return (
|
|
1939
|
+
getExitCode(error) ?? (error instanceof TlaModuleError ? error.exitCode : EXIT_STATUS.error)
|
|
1940
|
+
);
|
|
1941
|
+
}
|
|
1942
|
+
// TLC exits with the code of a failed replay of the initial states regardless of the error, as
|
|
1943
|
+
// it does for a replay that fails to fingerprint.
|
|
1944
|
+
return failureOptions.isInitial || failureOptions.fingerprint
|
|
1945
|
+
? EXIT_STATUS.specEvaluationFailure
|
|
1946
|
+
: getReplayExitCode(error);
|
|
1947
|
+
};
|
|
1948
|
+
const toFailure = (failed: unknown, behavior: Behavior, failureOptions: FailureOptions = {}) => {
|
|
1949
|
+
const error = isStackOverflow(failed) ? new TlaStackOverflowError() : failed;
|
|
1366
1950
|
if (!(error instanceof TlaEvaluationError)) throw error;
|
|
1951
|
+
const checked =
|
|
1952
|
+
behavior.trace.length > 0 && !failureOptions.traceFailure
|
|
1953
|
+
? checkTracePostconditions(behavior.trace, undefined)
|
|
1954
|
+
: undefined;
|
|
1955
|
+
const postcondition = checked?.unwitnessed ?? checked?.postcondition;
|
|
1956
|
+
const traceOutput = [...(behavior.traceOutput ?? []), ...(checked?.lines ?? [])];
|
|
1367
1957
|
return {
|
|
1368
1958
|
...createResult("error", undefined, {
|
|
1369
|
-
|
|
1370
|
-
|
|
1959
|
+
...getFailureMessage(error, failureOptions.isNextState ?? false),
|
|
1960
|
+
...behavior,
|
|
1961
|
+
...(traceOutput.length > 0 && { traceOutput }),
|
|
1962
|
+
...(postcondition && { postcondition }),
|
|
1371
1963
|
initialState:
|
|
1372
|
-
initialState && !(error instanceof TlaModuleError)
|
|
1373
|
-
|
|
1964
|
+
failureOptions.initialState && !(error instanceof TlaModuleError)
|
|
1965
|
+
? toRecord(failureOptions.initialState)
|
|
1966
|
+
: undefined,
|
|
1967
|
+
exitCode: getFailureExitCode(error, failureOptions),
|
|
1968
|
+
callStack: failureOptions.callStack,
|
|
1969
|
+
...(failureOptions.isCallStackFirst && { isCallStackFirst: true }),
|
|
1970
|
+
...(failureOptions.fingerprint && { fingerprint: failureOptions.fingerprint }),
|
|
1971
|
+
...(failureOptions.traceFailure && { traceFailure: failureOptions.traceFailure }),
|
|
1374
1972
|
}),
|
|
1375
|
-
outDegrees:
|
|
1973
|
+
outDegrees: failureOptions.outDegrees,
|
|
1376
1974
|
};
|
|
1377
1975
|
};
|
|
1976
|
+
// TLC reports a successor state that an action leaves incomplete with the trace to it, which ends
|
|
1977
|
+
// with the partial state. It names the action when the next-state relation has several.
|
|
1978
|
+
const reportIncompleteSuccessor = (index: number, error: TlaIncompleteSuccessorError) => {
|
|
1979
|
+
runtime.generatedStates++;
|
|
1980
|
+
const actions = getSpecNextActions();
|
|
1981
|
+
const action =
|
|
1982
|
+
actions.length === 1 ? actions[0] : actions.find((item) => item.name === error.action);
|
|
1983
|
+
const missing = error.variables;
|
|
1984
|
+
const subject =
|
|
1985
|
+
actions.length === 1
|
|
1986
|
+
? "the next-state action"
|
|
1987
|
+
: `action ${error.action} of the next-state relation`;
|
|
1988
|
+
// TLC 1.7.4 says a variable is not assigned rather than not defined.
|
|
1989
|
+
const verb = is174 ? "assigned" : "defined";
|
|
1990
|
+
const message = `Successor state is not completely specified by ${subject}. The following variable${missing.length > 1 ? "s are" : " is"} not ${verb}: ${missing.join(", ")}.\n`;
|
|
1991
|
+
const undefinedValue = createModelValue("null");
|
|
1992
|
+
const partial = error.state.map((value) => value ?? undefinedValue);
|
|
1993
|
+
const failure = toFailure(error, getStateTrace(index));
|
|
1994
|
+
return withOutDegrees({
|
|
1995
|
+
...failure,
|
|
1996
|
+
failure: failure.failure && {
|
|
1997
|
+
...failure.failure,
|
|
1998
|
+
code: MESSAGE_CODE.incompleteSuccessor,
|
|
1999
|
+
message,
|
|
2000
|
+
toolMessage: message,
|
|
2001
|
+
exitCode: EXIT_STATUS.specEvaluationFailure,
|
|
2002
|
+
trace: [
|
|
2003
|
+
...failure.failure.trace,
|
|
2004
|
+
{
|
|
2005
|
+
action: error.action,
|
|
2006
|
+
label: action && getActionLabel(action, options.version),
|
|
2007
|
+
state: toRecord(partial),
|
|
2008
|
+
},
|
|
2009
|
+
],
|
|
2010
|
+
},
|
|
2011
|
+
});
|
|
2012
|
+
};
|
|
1378
2013
|
const getPathSteps = (path: number[], loopStart?: number) => {
|
|
1379
2014
|
const steps = getPathStates(path, NEXT_RECOVERY_FAILURE);
|
|
1380
2015
|
const last = steps[steps.length - 1].state;
|
|
@@ -1390,9 +2025,15 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1390
2025
|
let hash = 0x811c9dc5;
|
|
1391
2026
|
for (let index = 0; index < state.length; index++)
|
|
1392
2027
|
hash = combineHash(hash, getValueHash(state[index]));
|
|
1393
|
-
assertFingerprintable(state);
|
|
1394
2028
|
return hash & 0x3fffffff;
|
|
1395
2029
|
};
|
|
2030
|
+
// TLC fingerprints a state once it finds the state in the model.
|
|
2031
|
+
const fingerprintModelState = (state: Value[]) => {
|
|
2032
|
+
for (const value of state) {
|
|
2033
|
+
const error = getFingerprintError(value);
|
|
2034
|
+
if (error) throw error;
|
|
2035
|
+
}
|
|
2036
|
+
};
|
|
1396
2037
|
const isSameState = (stored: Value[], state: Value[]) => {
|
|
1397
2038
|
for (let position = 0; position < state.length; position++) {
|
|
1398
2039
|
if (!isSameValue(stored[position], state[position])) return false;
|
|
@@ -1429,6 +2070,9 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1429
2070
|
}
|
|
1430
2071
|
insertSeen(hash, index + 1);
|
|
1431
2072
|
};
|
|
2073
|
+
// A new successor that TLC has added to its set of states before it checks the successor, which
|
|
2074
|
+
// the check stores after.
|
|
2075
|
+
const unstoredState = { fingerprint: undefined as Value[] | undefined };
|
|
1432
2076
|
const countDistinctState = (depth: number) => {
|
|
1433
2077
|
runtime.distinctStates = states.length + 1;
|
|
1434
2078
|
statistics.depth = Math.max(statistics.depth, depth);
|
|
@@ -1453,7 +2097,6 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1453
2097
|
isExpanding: false,
|
|
1454
2098
|
candidate: undefined as Value[] | undefined,
|
|
1455
2099
|
candidateLevel: 0,
|
|
1456
|
-
isFingerprinting: false,
|
|
1457
2100
|
livenessSource: -1,
|
|
1458
2101
|
};
|
|
1459
2102
|
const getPath = (index: number): Value[][] =>
|
|
@@ -1472,6 +2115,11 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1472
2115
|
};
|
|
1473
2116
|
runtime.getLevel = (state) => {
|
|
1474
2117
|
const source = current.livenessSource;
|
|
2118
|
+
// TLC 1.7.4 reads the level of the state its worker explores, whichever state it evaluates.
|
|
2119
|
+
if (is174) {
|
|
2120
|
+
const explored = source !== -1 ? source : current.isExpanding ? current.index : -1;
|
|
2121
|
+
return explored === -1 ? 0 : depths[explored];
|
|
2122
|
+
}
|
|
1475
2123
|
if (source !== -1) return state === states[source] ? depths[source] : depths[source] + 1;
|
|
1476
2124
|
if (state === current.candidate) return current.candidateLevel;
|
|
1477
2125
|
if (current.index === -1) return 0;
|
|
@@ -1500,9 +2148,14 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1500
2148
|
const fingerprintState = getFingerprintState(state);
|
|
1501
2149
|
const hash = getStateHash(fingerprintState);
|
|
1502
2150
|
const isInModel = search.satisfiesConstraints(state);
|
|
1503
|
-
if (isInModel)
|
|
2151
|
+
if (isInModel) {
|
|
2152
|
+
search.trackStatePossible(state);
|
|
2153
|
+
fingerprintModelState(fingerprintState);
|
|
2154
|
+
state.forEach(markFingerprinted);
|
|
2155
|
+
}
|
|
1504
2156
|
const isSeen = isInModel && findStateIndex(hash, fingerprintState) !== -1;
|
|
1505
2157
|
if (isSeen) return undefined;
|
|
2158
|
+
unstoredState.fingerprint = isInModel ? fingerprintState : undefined;
|
|
1506
2159
|
if (isInModel) {
|
|
1507
2160
|
countDistinctState(1);
|
|
1508
2161
|
runtime.queueSize++;
|
|
@@ -1513,14 +2166,14 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1513
2166
|
if (violated) {
|
|
1514
2167
|
return reportViolation("invariant-violation", {
|
|
1515
2168
|
name: violated.name,
|
|
1516
|
-
|
|
2169
|
+
...toTrace([{ action: undefined, state }], []),
|
|
1517
2170
|
});
|
|
1518
2171
|
}
|
|
1519
2172
|
const failedPredicate = search.findFailedInitialPredicate(state);
|
|
1520
2173
|
if (failedPredicate) {
|
|
1521
2174
|
return reportViolation("liveness-violation", {
|
|
1522
2175
|
name: failedPredicate.name,
|
|
1523
|
-
|
|
2176
|
+
...toTrace([{ action: undefined, state }], []),
|
|
1524
2177
|
});
|
|
1525
2178
|
}
|
|
1526
2179
|
if (!isInModel) return undefined;
|
|
@@ -1540,15 +2193,17 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1540
2193
|
current.candidate = successor.state;
|
|
1541
2194
|
current.candidateLevel = depths[index] + 1;
|
|
1542
2195
|
if (isCanonicalizedFirst) canonicalizeState(successor.state);
|
|
1543
|
-
current.isFingerprinting = true;
|
|
1544
2196
|
const fingerprintState = getFingerprintState(successor.state);
|
|
1545
2197
|
const hash = getStateHash(fingerprintState);
|
|
1546
|
-
current.isFingerprinting = false;
|
|
1547
2198
|
const found = findStateIndex(hash, fingerprintState);
|
|
1548
2199
|
const isStateInModel = search.satisfiesConstraints(successor.state, state);
|
|
1549
2200
|
if (isStateInModel) search.trackStatePossible(successor.state);
|
|
1550
2201
|
const isInModel = isStateInModel && search.satisfiesActionConstraints(state, successor.state);
|
|
1551
|
-
if (isInModel)
|
|
2202
|
+
if (isInModel) {
|
|
2203
|
+
search.trackActionPossible(state, successor.state);
|
|
2204
|
+
fingerprintModelState(fingerprintState);
|
|
2205
|
+
successor.state.forEach(markFingerprinted);
|
|
2206
|
+
}
|
|
1552
2207
|
const existing = isInModel ? found : -1;
|
|
1553
2208
|
if (source && isInModel) {
|
|
1554
2209
|
stateWriter?.writeSuccessor(
|
|
@@ -1564,6 +2219,9 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1564
2219
|
liveSuccessors.push({ index: existing, state: isStored ? stored : successor.state });
|
|
1565
2220
|
}
|
|
1566
2221
|
const isNew = isInModel && existing === -1;
|
|
2222
|
+
// TLC adds a new state to the behavior graph's successors before it checks the invariants.
|
|
2223
|
+
if (isNew && liveness) liveSuccessors.push({ index: states.length, state: successor.state });
|
|
2224
|
+
unstoredState.fingerprint = isNew ? fingerprintState : undefined;
|
|
1567
2225
|
if (isNew) {
|
|
1568
2226
|
countDistinctState(depths[index] + 1);
|
|
1569
2227
|
expansion.newStates++;
|
|
@@ -1572,65 +2230,105 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1572
2230
|
try {
|
|
1573
2231
|
const violated = search.findViolatedInvariant(successor.state, state);
|
|
1574
2232
|
if (violated) {
|
|
1575
|
-
return
|
|
1576
|
-
|
|
1577
|
-
|
|
1578
|
-
|
|
2233
|
+
return withOutDegrees(
|
|
2234
|
+
reportViolation("invariant-violation", {
|
|
2235
|
+
name: violated.name,
|
|
2236
|
+
...getTrace(index, successor),
|
|
2237
|
+
}),
|
|
2238
|
+
);
|
|
1579
2239
|
}
|
|
1580
2240
|
} catch (error) {
|
|
1581
|
-
|
|
1582
|
-
|
|
2241
|
+
if (isStackOverflow(error)) throw error;
|
|
2242
|
+
// TLC replays the expansion and skips the invariants of a state it has seen, the failed one
|
|
2243
|
+
// included unless the constraints exclude it. When the replay fails, TLC reports where and
|
|
2244
|
+
// leaves out the outdegree.
|
|
2245
|
+
const replay = getOutput(() => replayNext(state));
|
|
2246
|
+
return toFailure(
|
|
2247
|
+
error,
|
|
2248
|
+
appendTraceOutput(getFailedTrace(index, successor), replay.lines),
|
|
2249
|
+
replay.result ?? { outDegrees: getFailureOutDegrees() },
|
|
2250
|
+
);
|
|
1583
2251
|
}
|
|
1584
2252
|
}
|
|
1585
2253
|
const violatedProperty = search.findViolatedActionProperty(state, successor.state);
|
|
1586
2254
|
if (violatedProperty) {
|
|
1587
|
-
return
|
|
1588
|
-
|
|
1589
|
-
|
|
1590
|
-
|
|
2255
|
+
return withOutDegrees(
|
|
2256
|
+
reportViolation("liveness-violation", {
|
|
2257
|
+
name: violatedProperty.name,
|
|
2258
|
+
...getTrace(index, successor),
|
|
2259
|
+
}),
|
|
2260
|
+
);
|
|
1591
2261
|
}
|
|
1592
2262
|
if (!isNew) return undefined;
|
|
1593
2263
|
if (!isCanonicalizedFirst) canonicalizeState(successor.state);
|
|
1594
2264
|
markSeen(hash, states.length);
|
|
1595
|
-
if (liveness) liveSuccessors.push({ index: states.length, state: successor.state });
|
|
1596
2265
|
addState(successor.state, fingerprintState, index, successor.action);
|
|
1597
2266
|
runtime.queueSize++;
|
|
1598
2267
|
return undefined;
|
|
1599
2268
|
};
|
|
1600
2269
|
|
|
1601
2270
|
const outcome: { result: CheckResult | undefined } = { result: undefined };
|
|
2271
|
+
if (liveness) {
|
|
2272
|
+
options.onProgress?.({ kind: "liveness-prepared", branches: liveness.branches });
|
|
2273
|
+
}
|
|
2274
|
+
// TLC checks the assumptions once it has built the liveness checker in ModelChecker's
|
|
2275
|
+
// constructor.
|
|
2276
|
+
const assumptionViolation = findViolatedAssumption();
|
|
2277
|
+
if (assumptionViolation) return createResult("assumption-violation", assumptionViolation);
|
|
2278
|
+
options.onProgress?.({ kind: "initial-states-started" });
|
|
1602
2279
|
if (spec.init !== undefined) {
|
|
1603
2280
|
try {
|
|
1604
2281
|
forEachInitialState(
|
|
1605
2282
|
spec.init,
|
|
1606
2283
|
environment,
|
|
1607
2284
|
(state) => {
|
|
2285
|
+
reportInitialStatesProgress(runtime.initialStates, options.onProgress);
|
|
1608
2286
|
try {
|
|
1609
2287
|
outcome.result = visitInitialState(state);
|
|
1610
2288
|
} catch (error) {
|
|
1611
|
-
|
|
2289
|
+
const replay = getOutput(replayInit);
|
|
2290
|
+
outcome.result = toFailure(
|
|
2291
|
+
error,
|
|
2292
|
+
{ trace: [], traceOutput: replay.lines },
|
|
2293
|
+
{ initialState: state, ...replay.result, isInitial: true },
|
|
2294
|
+
);
|
|
1612
2295
|
}
|
|
1613
2296
|
return outcome.result !== undefined;
|
|
1614
2297
|
},
|
|
1615
2298
|
spec.scope,
|
|
1616
2299
|
);
|
|
1617
2300
|
} catch (error) {
|
|
1618
|
-
if (!(error instanceof TlaIllegalStateError))
|
|
1619
|
-
return replayInitialStates(toFailure(error, []));
|
|
1620
2301
|
// TLC prints an illegal initial state with null for each variable it leaves undefined, and
|
|
1621
2302
|
// stops before it prints the statistics.
|
|
1622
|
-
|
|
2303
|
+
if (error instanceof TlaIllegalStateError) {
|
|
2304
|
+
const illegal = toFailure(
|
|
2305
|
+
error,
|
|
2306
|
+
{ trace: [] },
|
|
2307
|
+
{ initialState: error.state.map((value) => value ?? createModelValue("null")) },
|
|
2308
|
+
);
|
|
2309
|
+
return {
|
|
2310
|
+
...illegal,
|
|
2311
|
+
failure: illegal.failure && { ...illegal.failure, isWithoutStatistics: true },
|
|
2312
|
+
};
|
|
2313
|
+
}
|
|
2314
|
+
// TLC prints the error before it replays the initial predicate with its call stack.
|
|
2315
|
+
const replay = getOutput(replayInit);
|
|
2316
|
+
return toFailure(
|
|
1623
2317
|
error,
|
|
1624
|
-
[],
|
|
1625
|
-
|
|
2318
|
+
{ trace: [], traceOutput: replay.lines },
|
|
2319
|
+
{ ...replay.result, isInitial: true },
|
|
1626
2320
|
);
|
|
1627
|
-
return {
|
|
1628
|
-
...illegal,
|
|
1629
|
-
failure: illegal.failure && { ...illegal.failure, isWithoutStatistics: true },
|
|
1630
|
-
};
|
|
1631
2321
|
}
|
|
1632
2322
|
}
|
|
1633
|
-
if (outcome.result) return
|
|
2323
|
+
if (outcome.result) return outcome.result;
|
|
2324
|
+
statistics.initialStates = {
|
|
2325
|
+
generated: runtime.initialStates,
|
|
2326
|
+
distinct: runtime.distinctStates,
|
|
2327
|
+
};
|
|
2328
|
+
options.onProgress?.({
|
|
2329
|
+
kind: "initial-states-computed",
|
|
2330
|
+
initialStates: statistics.initialStates,
|
|
2331
|
+
});
|
|
1634
2332
|
|
|
1635
2333
|
const next = spec.next;
|
|
1636
2334
|
if (next === undefined) {
|
|
@@ -1659,9 +2357,8 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1659
2357
|
spec.scope,
|
|
1660
2358
|
);
|
|
1661
2359
|
}
|
|
1662
|
-
nextActions.value ??= getNextActions(config, environment, specification.instanceActions);
|
|
1663
2360
|
const progress = { isStopped: false };
|
|
1664
|
-
return
|
|
2361
|
+
return getSpecNextActions().reduce((count, action) => {
|
|
1665
2362
|
if (progress.isStopped) return count;
|
|
1666
2363
|
return (
|
|
1667
2364
|
count +
|
|
@@ -1678,100 +2375,240 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1678
2375
|
);
|
|
1679
2376
|
}, 0);
|
|
1680
2377
|
};
|
|
1681
|
-
|
|
2378
|
+
// TLC's worker adds a state to the behavior graph even after its next states fail or violate a
|
|
2379
|
+
// property, and prints the call stack of an error in that, unless the error is a
|
|
2380
|
+
// FingerprintException, which the worker doesn't catch. TLC 1.7.4 prints none.
|
|
2381
|
+
const getLiveCallStack = (index: number, liveSuccessors: LiveSuccessor[]) => {
|
|
2382
|
+
if (!liveness || is174) return undefined;
|
|
2383
|
+
const replay = getReplayFailure((tracing) =>
|
|
2384
|
+
liveness.addState(index, states[index], liveSuccessors, tracing),
|
|
2385
|
+
);
|
|
2386
|
+
return replay?.callStack.length && !replay.fingerprint ? replay.callStack : undefined;
|
|
2387
|
+
};
|
|
2388
|
+
// TLC's worker adds the state to the behavior graph after it prints the trace. On an error in that,
|
|
2389
|
+
// it adds the state again to print the call stack instead of replaying the next-state relation,
|
|
2390
|
+
// which TLC 1.7.4 doesn't.
|
|
2391
|
+
const addFailedLiveState = (index: number, liveSuccessors: LiveSuccessor[]) => {
|
|
2392
|
+
try {
|
|
2393
|
+
liveness?.addState(index, states[index], liveSuccessors);
|
|
2394
|
+
return undefined;
|
|
2395
|
+
} catch (error) {
|
|
2396
|
+
if (!(error instanceof TlaEvaluationError)) throw error;
|
|
2397
|
+
return getLiveCallStack(index, liveSuccessors);
|
|
2398
|
+
}
|
|
2399
|
+
};
|
|
2400
|
+
const replayFailedNext = (index: number, liveSuccessors: LiveSuccessor[]) => {
|
|
2401
|
+
const live = getOutput(() => addFailedLiveState(index, liveSuccessors));
|
|
2402
|
+
if (live.result) {
|
|
2403
|
+
const result = { callStack: live.result, fingerprint: undefined, isLiveCallStack: true };
|
|
2404
|
+
return { result, lines: live.lines };
|
|
2405
|
+
}
|
|
2406
|
+
const replay = getOutput(() => replayNext(states[index]));
|
|
2407
|
+
return { result: replay.result, lines: [...live.lines, ...replay.lines] };
|
|
2408
|
+
};
|
|
2409
|
+
// TLC reports a stack overflow while it computes next states without replaying it, with the
|
|
2410
|
+
// behavior up to the state it expands.
|
|
2411
|
+
const reportNextStateOverflow = (index: number) =>
|
|
2412
|
+
toFailure(createStackOverflowError(), getStateTrace(index));
|
|
2413
|
+
// After the trace, TLC replays the next-state relation with its call stack, printing again.
|
|
2414
|
+
const reportNextStateFailure = (
|
|
2415
|
+
error: unknown,
|
|
2416
|
+
index: number,
|
|
2417
|
+
liveSuccessors: LiveSuccessor[],
|
|
2418
|
+
) => {
|
|
2419
|
+
if (isStackOverflow(error)) return reportNextStateOverflow(index);
|
|
2420
|
+
const replay = replayFailedNext(index, liveSuccessors);
|
|
2421
|
+
return toFailure(
|
|
2422
|
+
withNextStateExitCode(error),
|
|
2423
|
+
appendTraceOutput(getStateTrace(index), replay.lines),
|
|
2424
|
+
{ isNextState: true, ...replay.result },
|
|
2425
|
+
);
|
|
2426
|
+
};
|
|
2427
|
+
const expandState = (index: number, liveSuccessors: LiveSuccessor[]) => {
|
|
1682
2428
|
const state = states[index];
|
|
1683
|
-
const liveSuccessors: LiveSuccessor[] = [];
|
|
1684
2429
|
const source = stateWriter && getGraphState(state, depths[index]);
|
|
1685
2430
|
const successorCount = forEachActionSuccessor(state, (successor, action) => {
|
|
1686
2431
|
try {
|
|
1687
2432
|
outcome.result = visitSuccessor(index, successor, liveSuccessors, source, action);
|
|
1688
2433
|
} catch (error) {
|
|
1689
|
-
|
|
1690
|
-
|
|
1691
|
-
|
|
1692
|
-
|
|
2434
|
+
if (isStackOverflow(error)) {
|
|
2435
|
+
outcome.result = reportNextStateOverflow(index);
|
|
2436
|
+
return true;
|
|
2437
|
+
}
|
|
2438
|
+
// TLC 1.7.4 reports the wrapped error without the trace, except for a failed property,
|
|
2439
|
+
// which it reports with the trace before it rethrows. The error stops its worker before it
|
|
2440
|
+
// adds the state to the behavior graph.
|
|
2441
|
+
const replay = is174
|
|
2442
|
+
? getOutput(() => replayNext(state))
|
|
2443
|
+
: replayFailedNext(index, liveSuccessors);
|
|
2444
|
+
if (is174 && error instanceof TlaEvaluationError && !headedErrors.has(error)) {
|
|
2445
|
+
outcome.result = toFailure(
|
|
2446
|
+
new TlaEvaluationError(`${getWrappedException(error)}${error.message}`, error),
|
|
2447
|
+
appendTraceOutput({ trace: [] }, replay.lines),
|
|
2448
|
+
{ isNextState: true, ...replay.result },
|
|
2449
|
+
);
|
|
2450
|
+
return true;
|
|
2451
|
+
}
|
|
2452
|
+
// A successor TLC can't fingerprint fails again as TLC prints it in the trace, which TLC
|
|
2453
|
+
// reports as an exception it didn't expect.
|
|
2454
|
+
const isTraceFailed = getFingerprintState(successor.state).some(
|
|
2455
|
+
(value) => getFingerprintError(value) !== undefined,
|
|
2456
|
+
);
|
|
2457
|
+
const traceFailure =
|
|
2458
|
+
isTraceFailed && error instanceof TlaEvaluationError
|
|
2459
|
+
? getFailureMessage(
|
|
2460
|
+
isEvalException(error)
|
|
2461
|
+
? new TlaEvaluationError(`${UNEXPECTED_EVAL_EXCEPTION}${error.message}`)
|
|
2462
|
+
: error,
|
|
2463
|
+
true,
|
|
2464
|
+
)
|
|
2465
|
+
: undefined;
|
|
2466
|
+
outcome.result = toFailure(
|
|
2467
|
+
error,
|
|
2468
|
+
appendTraceOutput(
|
|
2469
|
+
traceFailure ? getStateTrace(index) : getFailedTrace(index, successor),
|
|
2470
|
+
replay.lines,
|
|
2471
|
+
),
|
|
2472
|
+
{ isNextState: true, ...replay.result, traceFailure },
|
|
2473
|
+
);
|
|
1693
2474
|
}
|
|
1694
2475
|
return outcome.result !== undefined;
|
|
1695
2476
|
});
|
|
1696
2477
|
current.isExpanding = false;
|
|
1697
|
-
|
|
1698
|
-
|
|
1699
|
-
|
|
2478
|
+
const result = outcome.result;
|
|
2479
|
+
// TLC 1.7.4's worker stops at a violation.
|
|
2480
|
+
if (result?.violation && !is174) {
|
|
2481
|
+
const live = getOutput(() => addFailedLiveState(index, liveSuccessors));
|
|
2482
|
+
return {
|
|
2483
|
+
...result,
|
|
2484
|
+
violation: appendTraceOutput(result.violation, live.lines),
|
|
2485
|
+
...(live.result && { liveCallStack: live.result }),
|
|
2486
|
+
};
|
|
1700
2487
|
}
|
|
1701
|
-
|
|
2488
|
+
if (result) return result;
|
|
2489
|
+
const addLiveState = () => {
|
|
2490
|
+
if (liveness && source && is174) stateWriter?.writeStuttering(source);
|
|
1702
2491
|
const accepted = liveness?.addState(index, state, liveSuccessors);
|
|
1703
2492
|
if (!liveness || !accepted) return undefined;
|
|
1704
2493
|
const steps = getPathSteps(accepted);
|
|
1705
|
-
const properties =
|
|
2494
|
+
const properties = getViolatedProperties(
|
|
2495
|
+
liveness,
|
|
1706
2496
|
steps.map((step) => step.state),
|
|
1707
2497
|
steps.length - 1,
|
|
1708
2498
|
);
|
|
1709
2499
|
return reportViolation("property-violation", {
|
|
1710
2500
|
name: properties[0],
|
|
1711
2501
|
properties,
|
|
1712
|
-
|
|
2502
|
+
...toTrace(steps, accepted, { known: 0 }),
|
|
2503
|
+
});
|
|
2504
|
+
};
|
|
2505
|
+
if (successorCount === 0 && config.checkDeadlock) {
|
|
2506
|
+
const deadlock = reportViolation("deadlock", { name: "deadlock", ...getStateTrace(index) });
|
|
2507
|
+
// TLC's worker still adds the deadlocked state to the behavior graph after it reports the
|
|
2508
|
+
// deadlock, and reports a temporal property that this violates. Then it counts the state as
|
|
2509
|
+
// expanded.
|
|
2510
|
+
const live = getOutput(() => {
|
|
2511
|
+
try {
|
|
2512
|
+
return { additional: addLiveState()?.violation };
|
|
2513
|
+
} catch (error) {
|
|
2514
|
+
if (!(error instanceof TlaEvaluationError)) throw error;
|
|
2515
|
+
return { isFailed: true, callStack: getLiveCallStack(index, liveSuccessors) };
|
|
2516
|
+
}
|
|
1713
2517
|
});
|
|
2518
|
+
const reported = deadlock.violation
|
|
2519
|
+
? { ...deadlock, violation: appendTraceOutput(deadlock.violation, live.lines) }
|
|
2520
|
+
: deadlock;
|
|
2521
|
+
// An error in adding the state stops TLC 1.7.4's worker before it counts the state.
|
|
2522
|
+
const counted = withOutDegrees(
|
|
2523
|
+
reported,
|
|
2524
|
+
live.result.isFailed ? getFailureOutDegrees() : getPartialOutDegrees(),
|
|
2525
|
+
);
|
|
2526
|
+
if (live.result.additional)
|
|
2527
|
+
return { ...counted, additionalViolation: live.result.additional };
|
|
2528
|
+
return live.result.callStack ? { ...counted, liveCallStack: live.result.callStack } : counted;
|
|
2529
|
+
}
|
|
2530
|
+
try {
|
|
2531
|
+
return addLiveState();
|
|
1714
2532
|
} catch (error) {
|
|
1715
|
-
|
|
1716
|
-
|
|
1717
|
-
|
|
1718
|
-
|
|
1719
|
-
|
|
1720
|
-
|
|
1721
|
-
|
|
1722
|
-
|
|
1723
|
-
|
|
1724
|
-
|
|
2533
|
+
// TLC 1.7.4's worker reports an error in adding a state to the behavior graph as an exception
|
|
2534
|
+
// it didn't expect, without the trace or a call stack, and exits as for any general error.
|
|
2535
|
+
if (is174 && error instanceof TlaEvaluationError) {
|
|
2536
|
+
const unexpected = new TlaEvaluationError(
|
|
2537
|
+
`${isEvalException(error) ? UNEXPECTED_EVAL_EXCEPTION : UNEXPECTED_EXCEPTION}${error.message}`,
|
|
2538
|
+
);
|
|
2539
|
+
return toFailure(
|
|
2540
|
+
setExitCode(unexpected, EXIT_STATUS.error),
|
|
2541
|
+
{ trace: [] },
|
|
2542
|
+
{ outDegrees: getFailureOutDegrees() },
|
|
2543
|
+
);
|
|
2544
|
+
}
|
|
2545
|
+
// TLC's Worker#doNextCheckLiveness adds the state again to find the call stack, prints it
|
|
2546
|
+
// before the error, and reports the error as one in computing next states.
|
|
2547
|
+
const replay = getReplayFailure((tracing) =>
|
|
2548
|
+
liveness?.addState(index, state, liveSuccessors, tracing),
|
|
1725
2549
|
);
|
|
2550
|
+
return toFailure(error, getStateTrace(index), {
|
|
2551
|
+
outDegrees: getFailureOutDegrees(),
|
|
2552
|
+
callStack: replay?.callStack.length ? replay.callStack : undefined,
|
|
2553
|
+
isNextState: true,
|
|
2554
|
+
isCallStackFirst: true,
|
|
2555
|
+
});
|
|
1726
2556
|
}
|
|
1727
2557
|
};
|
|
1728
|
-
// TLC
|
|
1729
|
-
|
|
1730
|
-
|
|
1731
|
-
|
|
1732
|
-
|
|
1733
|
-
|
|
1734
|
-
|
|
1735
|
-
|
|
1736
|
-
|
|
1737
|
-
|
|
1738
|
-
|
|
1739
|
-
|
|
1740
|
-
|
|
1741
|
-
|
|
1742
|
-
|
|
1743
|
-
|
|
1744
|
-
|
|
1745
|
-
{
|
|
1746
|
-
action: error.action,
|
|
1747
|
-
label: action && getActionLabel(action),
|
|
1748
|
-
state: toRecord(error.state.map((value) => value ?? createModelValue("null"))),
|
|
1749
|
-
},
|
|
1750
|
-
],
|
|
1751
|
-
);
|
|
2558
|
+
// TLC's Liveness#printStutteringCounterExampleWarning.
|
|
2559
|
+
const getStutteringWarning = () => {
|
|
2560
|
+
const name = config.specification;
|
|
2561
|
+
const book =
|
|
2562
|
+
"(compare Chapter 8, page 87ff of Specifying Systems at https://lamport.azurewebsites.net/tla/book.html).";
|
|
2563
|
+
if (name === undefined) {
|
|
2564
|
+
return {
|
|
2565
|
+
code: MESSAGE_CODE.noSpecificationButProperty,
|
|
2566
|
+
text: `The stuttering counterexample above may be caused by the absence of a behavior specification (SPECIFICATION). Only INIT and NEXT have been provided, so TLC permits infinite stuttering. To rule out such counterexamples, use SPECIFICATION Spec, with Spec asserting a suitable fairness constraint ${book}`,
|
|
2567
|
+
};
|
|
2568
|
+
}
|
|
2569
|
+
const range = getDefinition(name, environment)?.location.range;
|
|
2570
|
+
if (spec.temporals.length > 0 || !range) return undefined;
|
|
2571
|
+
return {
|
|
2572
|
+
code: MESSAGE_CODE.noFairnessButProperty,
|
|
2573
|
+
text: `The stuttering counterexample above may be caused by the absence of a fairness constraint in the behavior specification ${name} defined at ${formatRange(range)}. To rule out such counterexamples, conjoin a suitable fairness constraint to ${name} ${book}`,
|
|
2574
|
+
};
|
|
1752
2575
|
};
|
|
1753
2576
|
// TLC names the properties and the step back into the cycle from the states it prints.
|
|
1754
2577
|
const reportLasso = (checker: LivenessChecker, lasso: Lasso) => {
|
|
1755
2578
|
const path = [...lasso.prefix, ...lasso.cycle];
|
|
1756
2579
|
const loopStart = lasso.prefix.length;
|
|
1757
2580
|
const steps = getPathSteps(path, loopStart);
|
|
1758
|
-
const trace = toTrace(steps, path, loopStart);
|
|
1759
|
-
const properties =
|
|
2581
|
+
const trace = toTrace(steps, path, { loopStart, known: 0 }).trace;
|
|
2582
|
+
const properties = getViolatedProperties(
|
|
2583
|
+
checker,
|
|
1760
2584
|
steps.map((step) => step.state),
|
|
1761
2585
|
loopStart,
|
|
1762
2586
|
);
|
|
1763
2587
|
const back = path[loopStart];
|
|
1764
2588
|
const last = path[path.length - 1];
|
|
1765
2589
|
const lastState = steps[steps.length - 1].state;
|
|
1766
|
-
const
|
|
1767
|
-
back === last
|
|
2590
|
+
const loop =
|
|
2591
|
+
back === last
|
|
2592
|
+
? { result: undefined, lines: [] }
|
|
2593
|
+
: getOutput(() => findStepAction(last, lastState, states[back], false));
|
|
2594
|
+
const isStutteringWarned = back === last && lasso.isCycleConstrained;
|
|
1768
2595
|
return reportViolation(
|
|
1769
2596
|
"liveness-violation",
|
|
1770
|
-
{
|
|
2597
|
+
{
|
|
2598
|
+
name: properties[0],
|
|
2599
|
+
properties,
|
|
2600
|
+
trace,
|
|
2601
|
+
traceOutput: loop.lines,
|
|
2602
|
+
loopStart,
|
|
2603
|
+
loopLabel: loop.result && getActionLabel(loop.result, options.version),
|
|
2604
|
+
warning: isStutteringWarned ? getStutteringWarning() : undefined,
|
|
2605
|
+
},
|
|
1771
2606
|
() =>
|
|
1772
2607
|
back === last
|
|
1773
|
-
? trace[trace.length - 1]
|
|
1774
|
-
:
|
|
2608
|
+
? getStepAction(trace[trace.length - 1])
|
|
2609
|
+
: loop.result
|
|
2610
|
+
? toActionValue(loop.result)
|
|
2611
|
+
: createActionRecord(findSuccessorWithFingerprint(lastState, back)?.action),
|
|
1775
2612
|
);
|
|
1776
2613
|
};
|
|
1777
2614
|
const isPeriodic = liveness !== undefined && options.livenessCheck !== "final";
|
|
@@ -1779,11 +2616,19 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1779
2616
|
const periodic = { at: startedAt + PERIODIC_START, size: 1, time: 0 };
|
|
1780
2617
|
const findPeriodicViolation = (expanded: number) => {
|
|
1781
2618
|
const now = performance.now();
|
|
1782
|
-
periodic.at = now + PROGRESS_INTERVAL;
|
|
1783
2619
|
const isGrown = (expanded - periodic.size) / periodic.size > LIVENESS_GROWTH;
|
|
1784
2620
|
if (!isGrown || periodic.time > (now - startedAt) * LIVENESS_RATIO) return undefined;
|
|
1785
2621
|
periodic.size = expanded;
|
|
1786
|
-
|
|
2622
|
+
if (!liveness) return undefined;
|
|
2623
|
+
options.onProgress?.({
|
|
2624
|
+
kind: "liveness-started",
|
|
2625
|
+
branches: liveness.branches,
|
|
2626
|
+
isComplete: false,
|
|
2627
|
+
states: expanded,
|
|
2628
|
+
statistics: createResult("success"),
|
|
2629
|
+
});
|
|
2630
|
+
const lasso = liveness.findViolation();
|
|
2631
|
+
if (!lasso) options.onProgress?.({ kind: "liveness-finished" });
|
|
1787
2632
|
periodic.time += performance.now() - now;
|
|
1788
2633
|
return lasso;
|
|
1789
2634
|
};
|
|
@@ -1792,35 +2637,57 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
|
|
|
1792
2637
|
current.candidate = undefined;
|
|
1793
2638
|
runtime.queueSize = states.length - index - 1;
|
|
1794
2639
|
current.isExpanding = true;
|
|
2640
|
+
const liveSuccessors: LiveSuccessor[] = [];
|
|
1795
2641
|
try {
|
|
1796
|
-
outcome.result = expandState(index);
|
|
2642
|
+
outcome.result = expandState(index, liveSuccessors);
|
|
1797
2643
|
} catch (error) {
|
|
1798
|
-
const failure =
|
|
1799
|
-
error instanceof TlaIncompleteStateError
|
|
1800
|
-
? reportIncompleteSuccessor(error, index)
|
|
1801
|
-
: toFailure(toNextStateError(error), getStateTrace(index));
|
|
1802
2644
|
outcome.result =
|
|
1803
|
-
error instanceof
|
|
1804
|
-
?
|
|
1805
|
-
:
|
|
2645
|
+
error instanceof TlaIncompleteSuccessorError
|
|
2646
|
+
? reportIncompleteSuccessor(index, error)
|
|
2647
|
+
: reportNextStateFailure(error, index, liveSuccessors);
|
|
1806
2648
|
}
|
|
1807
2649
|
if (outcome.result) return outcome.result;
|
|
1808
2650
|
outDegrees[getOutDegreeBucket()]++;
|
|
1809
2651
|
expansion.newStates = 0;
|
|
1810
|
-
|
|
1811
|
-
|
|
2652
|
+
// TLC's AbstractChecker#runTLC checks the liveness properties on the state graph so far, then
|
|
2653
|
+
// reports how far the search got.
|
|
2654
|
+
if ((isPeriodic || options.onProgress) && performance.now() >= periodic.at) {
|
|
2655
|
+
periodic.at = performance.now() + PROGRESS_INTERVAL;
|
|
2656
|
+
const lasso = isPeriodic ? findPeriodicViolation(index + 1) : undefined;
|
|
1812
2657
|
if (liveness && lasso) return reportLasso(liveness, lasso);
|
|
2658
|
+
options.onProgress?.({ kind: "progress", statistics: createResult("success") });
|
|
1813
2659
|
}
|
|
1814
2660
|
}
|
|
1815
2661
|
|
|
1816
2662
|
current.index = -1;
|
|
1817
2663
|
current.candidate = undefined;
|
|
2664
|
+
if (liveness) {
|
|
2665
|
+
options.onProgress?.({
|
|
2666
|
+
kind: "liveness-started",
|
|
2667
|
+
branches: liveness.branches,
|
|
2668
|
+
isComplete: true,
|
|
2669
|
+
states: runtime.distinctStates,
|
|
2670
|
+
statistics: createResult("success"),
|
|
2671
|
+
});
|
|
2672
|
+
}
|
|
1818
2673
|
const lasso = liveness?.findViolation();
|
|
1819
2674
|
if (liveness && lasso) return reportLasso(liveness, lasso);
|
|
1820
2675
|
|
|
1821
|
-
|
|
1822
|
-
if (
|
|
1823
|
-
|
|
2676
|
+
// TLC finishes the check of the temporal properties before it checks the postconditions.
|
|
2677
|
+
if (liveness) options.onProgress?.({ kind: "liveness-finished" });
|
|
2678
|
+
try {
|
|
2679
|
+
const postcondition = search.findPostconditionViolation();
|
|
2680
|
+
if (postcondition) {
|
|
2681
|
+
return createResult("postcondition-violation", {
|
|
2682
|
+
name: postcondition.name,
|
|
2683
|
+
message: postcondition.message,
|
|
2684
|
+
counts: postcondition.counts,
|
|
2685
|
+
trace: [],
|
|
2686
|
+
postcondition,
|
|
2687
|
+
});
|
|
2688
|
+
}
|
|
2689
|
+
} catch (error) {
|
|
2690
|
+
return toFailure(error, { trace: [] });
|
|
1824
2691
|
}
|
|
1825
2692
|
return createSuccess();
|
|
1826
2693
|
};
|