tla-ts 0.0.3-dev.b0f84e8 → 0.0.3-dev.b4e335d
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 +150 -8
- package/dist/index.d.ts +150 -8
- 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 -20
- package/dist/run-cli.js +1351 -20
- package/dist/transfer.cjs +86 -28
- package/dist/transfer.js +86 -28
- package/package.json +5 -1
- package/src/ast.ts +57 -6
- package/src/bags.ts +4 -7
- package/src/builtins.ts +29 -11
- package/src/bundled-modules.ts +3 -3
- package/src/canonical.ts +4 -3
- package/src/check.ts +1393 -226
- package/src/cli.ts +8 -1
- package/src/codegen.ts +68 -18
- package/src/config.ts +252 -179
- package/src/environment.ts +457 -132
- package/src/errors.ts +217 -3
- package/src/evaluate.ts +722 -112
- package/src/exit-codes.ts +5 -4
- package/src/index.ts +1 -0
- package/src/instances.ts +4 -2
- package/src/java-overrides.ts +104 -25
- package/src/levels.ts +183 -37
- package/src/lexer.ts +112 -29
- package/src/live-check.ts +220 -102
- package/src/liveness.ts +216 -52
- package/src/obligation-expression.ts +2 -2
- package/src/obligation-source.ts +2 -0
- package/src/parallel-worker.ts +8 -3
- package/src/parallel.ts +56 -5
- package/src/parser.ts +445 -147
- 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 +1465 -411
- package/src/run-cli.ts +1167 -155
- package/src/runtime.ts +16 -0
- package/src/sany-builtins.ts +147 -0
- package/src/sany-generator.ts +3128 -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 +26 -7
- package/src/standard-modules.ts +200 -148
- package/src/standard-ranges.ts +116 -0
- package/src/state-graph.ts +29 -6
- package/src/subexpressions.ts +221 -161
- package/src/substitution-levels.ts +38 -17
- package/src/successors.ts +207 -103
- package/src/symmetry.ts +180 -52
- package/src/tableau.ts +54 -25
- package/src/tlc-ext.ts +13 -17
- package/src/tlc-messages.ts +329 -0
- package/src/tlc-module.ts +46 -18
- package/src/tlc-order.ts +56 -6
- package/src/tlc-random.ts +37 -9
- package/src/tlc-replay.ts +655 -0
- package/src/tlc-summary.ts +20 -5
- package/src/tlc-version.ts +18 -0
- package/src/transfer.ts +15 -3
- package/src/value-sources.ts +29 -0
- package/src/values.ts +697 -180
package/src/liveness.ts
CHANGED
|
@@ -1,12 +1,15 @@
|
|
|
1
|
-
import { isLocallyResolved, type Definition, type Expression } from "./ast";
|
|
2
|
-
import {
|
|
1
|
+
import { isLocallyResolved, type Bound, type Definition, type Expression } from "./ast";
|
|
2
|
+
import { getUnexpectedException, TlaEvaluationError, TlaStackOverflowError } from "./errors";
|
|
3
3
|
import {
|
|
4
|
-
|
|
4
|
+
describeNode,
|
|
5
|
+
describeRange,
|
|
5
6
|
bindDefinitions,
|
|
6
7
|
bindOperatorArguments,
|
|
7
8
|
evaluate,
|
|
8
9
|
expectBoolean,
|
|
9
10
|
forEachBinding,
|
|
11
|
+
forEachBoundElement,
|
|
12
|
+
getBoundElements,
|
|
10
13
|
getDefinition,
|
|
11
14
|
lookupScope,
|
|
12
15
|
resolveApplyOperator,
|
|
@@ -20,6 +23,8 @@ import {
|
|
|
20
23
|
import { mapChildren } from "./instances";
|
|
21
24
|
import { ACTION_LEVEL, TEMPORAL_LEVEL } from "./levels";
|
|
22
25
|
import { isEnabled } from "./successors";
|
|
26
|
+
import { EXIT_STATUS, setExitCode } from "./exit-codes";
|
|
27
|
+
import { isEvalException } from "./tlc-messages";
|
|
23
28
|
import {
|
|
24
29
|
createBoolean,
|
|
25
30
|
createJunction,
|
|
@@ -36,12 +41,27 @@ export interface ScopedExpression {
|
|
|
36
41
|
scope: Scope | undefined;
|
|
37
42
|
}
|
|
38
43
|
|
|
44
|
+
// A part of a temporal formula, with the name TLC gives the part when the formula is a property:
|
|
45
|
+
// a conjunct's location, or the name of the definition the part is the body of.
|
|
46
|
+
interface ExpandedExpression extends ScopedExpression {
|
|
47
|
+
name: string | undefined;
|
|
48
|
+
}
|
|
49
|
+
|
|
39
50
|
export interface TemporalProperty extends ScopedExpression {
|
|
40
51
|
name: string;
|
|
41
52
|
}
|
|
42
53
|
|
|
43
54
|
const MAXIMUM_EXPANSION_DEPTH = 100;
|
|
44
55
|
|
|
56
|
+
export const createTautologyError = () =>
|
|
57
|
+
setExitCode(
|
|
58
|
+
new TlaEvaluationError("Temporal formula is a tautology (its negation is unsatisfiable)."),
|
|
59
|
+
EXIT_STATUS.livenessEvaluationFailure,
|
|
60
|
+
);
|
|
61
|
+
|
|
62
|
+
// TLC expands a temporal formula that refers to itself until Java's stack overflows.
|
|
63
|
+
const createStackOverflowError = () => setExitCode(new TlaStackOverflowError(), EXIT_STATUS.error);
|
|
64
|
+
|
|
45
65
|
const TEMPORAL_OPERATORS = new Set(["~>", "-+->"]);
|
|
46
66
|
|
|
47
67
|
const definitionLevels = new WeakMap<Definition, number>();
|
|
@@ -55,9 +75,10 @@ const getConstantContext = (environment: Environment, scope: Scope | undefined):
|
|
|
55
75
|
next: undefined,
|
|
56
76
|
});
|
|
57
77
|
|
|
58
|
-
|
|
78
|
+
// TLC adds the message of the error that stopped it, when it has one.
|
|
79
|
+
const createCannotHandleError = (expression: Expression, inner?: string) =>
|
|
59
80
|
new TlaEvaluationError(
|
|
60
|
-
`TLC cannot handle the temporal formula
|
|
81
|
+
`TLC cannot handle the temporal formula ${describeRange(expression)}${inner === undefined ? "" : `:\n${inner}`}`,
|
|
61
82
|
);
|
|
62
83
|
|
|
63
84
|
export const getLevel = (
|
|
@@ -80,7 +101,7 @@ export const getLevel = (
|
|
|
80
101
|
const definition = getDefinition(name, environment);
|
|
81
102
|
if (definition) return getDefinitionLevel(definition, environment);
|
|
82
103
|
const builtin = environment.builtins.get(environment.substitutions.get(name) ?? name);
|
|
83
|
-
return builtin ? (builtin.isStateLevel ? 1 : 0) : undefined;
|
|
104
|
+
return builtin ? (builtin.isStateLevel && !builtin.isLevelConstant ? 1 : 0) : undefined;
|
|
84
105
|
};
|
|
85
106
|
const getNameLevel = (name: string, node: Expression) => {
|
|
86
107
|
if (shadowed.has(name)) return 0;
|
|
@@ -144,21 +165,53 @@ const getDefinitionLevel = (definition: Definition, environment: Environment) =>
|
|
|
144
165
|
return level;
|
|
145
166
|
};
|
|
146
167
|
|
|
168
|
+
// TLC leaves a formula whose sets it fails to enumerate, and doesn't expect an EvalException.
|
|
169
|
+
const getUnrolledElements = (bounds: Bound[], context: Context) => {
|
|
170
|
+
try {
|
|
171
|
+
return getBoundElements(bounds, context);
|
|
172
|
+
} catch (error) {
|
|
173
|
+
if (!(error instanceof TlaEvaluationError)) throw error;
|
|
174
|
+
if (!isEvalException(error)) return undefined;
|
|
175
|
+
throw setExitCode(
|
|
176
|
+
new TlaEvaluationError(
|
|
177
|
+
`${getUnexpectedException("tlc2.tool.EvalException")}${error.message}`,
|
|
178
|
+
),
|
|
179
|
+
EXIT_STATUS.error,
|
|
180
|
+
);
|
|
181
|
+
}
|
|
182
|
+
};
|
|
183
|
+
|
|
147
184
|
export const expandTemporal = (
|
|
148
185
|
expression: Expression,
|
|
149
186
|
scope: Scope | undefined,
|
|
150
187
|
environment: Environment,
|
|
151
|
-
|
|
188
|
+
// Whether TLC expands the formula as a property, which unrolls each \A over a constant set.
|
|
189
|
+
isProperty: boolean,
|
|
152
190
|
expanding = new Set<Definition>(),
|
|
153
|
-
|
|
191
|
+
// Whether the expansion entered the body of an instance's definition. Like TLC, it then no
|
|
192
|
+
// longer expands an operator applied to arguments.
|
|
193
|
+
isSubstituted = false,
|
|
194
|
+
name?: string,
|
|
195
|
+
): ExpandedExpression[] => {
|
|
154
196
|
const expand = (
|
|
155
197
|
child: Expression,
|
|
156
198
|
childScope: Scope | undefined,
|
|
199
|
+
childName = name,
|
|
157
200
|
childExpanding = expanding,
|
|
158
|
-
|
|
159
|
-
|
|
201
|
+
definition?: Definition,
|
|
202
|
+
): ExpandedExpression[] =>
|
|
203
|
+
expandTemporal(
|
|
204
|
+
child,
|
|
205
|
+
childScope,
|
|
206
|
+
environment,
|
|
207
|
+
isProperty,
|
|
208
|
+
childExpanding,
|
|
209
|
+
isSubstituted ||
|
|
210
|
+
(definition !== undefined && environment.substitutedDefinitions.has(definition)),
|
|
211
|
+
childName,
|
|
212
|
+
);
|
|
160
213
|
if (expression.kind === "And") {
|
|
161
|
-
return expression.operands.flatMap((operand) => expand(operand, scope));
|
|
214
|
+
return expression.operands.flatMap((operand) => expand(operand, scope, describeRange(operand)));
|
|
162
215
|
}
|
|
163
216
|
if (expression.kind === "Label") return expand(expression.body, scope);
|
|
164
217
|
if (expression.kind === "Let") {
|
|
@@ -179,35 +232,59 @@ export const expandTemporal = (
|
|
|
179
232
|
getDefinitionLevel(definition, environment) > 0
|
|
180
233
|
) {
|
|
181
234
|
if (expanding.has(definition)) {
|
|
182
|
-
throw
|
|
235
|
+
throw createStackOverflowError();
|
|
183
236
|
}
|
|
184
|
-
return expand(
|
|
237
|
+
return expand(
|
|
238
|
+
definition.body,
|
|
239
|
+
undefined,
|
|
240
|
+
definition.name,
|
|
241
|
+
new Set([...expanding, definition]),
|
|
242
|
+
definition,
|
|
243
|
+
);
|
|
185
244
|
}
|
|
186
245
|
}
|
|
187
246
|
const context = getConstantContext(environment, scope);
|
|
188
|
-
|
|
247
|
+
// TLC 1.7.4 never expands an operator applied to arguments. A property expands every one it
|
|
248
|
+
// applies, but a specification only the temporal ones.
|
|
249
|
+
if (
|
|
250
|
+
expression.kind === "Apply" &&
|
|
251
|
+
environment.runtime.version !== "1.7.4" &&
|
|
252
|
+
(isProperty || getLevel(expression, scope, environment) === TEMPORAL_LEVEL)
|
|
253
|
+
) {
|
|
189
254
|
const operator = resolveApplyOperator(expression, context);
|
|
190
255
|
const definition = isLocallyResolved(expression)
|
|
191
256
|
? undefined
|
|
192
257
|
: getDefinition(expression.operator, environment);
|
|
193
|
-
|
|
194
|
-
|
|
258
|
+
const isExpandable =
|
|
259
|
+
operator?.kind === "Closure" &&
|
|
260
|
+
operator.params.length === expression.args.length &&
|
|
261
|
+
!definition?.isRecursive &&
|
|
262
|
+
!isSubstituted;
|
|
263
|
+
if (isExpandable) {
|
|
264
|
+
return expand(
|
|
265
|
+
operator.body,
|
|
266
|
+
bindOperatorArguments(operator, expression.args, context),
|
|
267
|
+
expression.operator,
|
|
268
|
+
expanding,
|
|
269
|
+
definition,
|
|
270
|
+
);
|
|
195
271
|
}
|
|
196
272
|
}
|
|
197
273
|
const isUnrolled =
|
|
198
|
-
|
|
274
|
+
isProperty &&
|
|
199
275
|
expression.kind === "Forall" &&
|
|
200
|
-
getLevel(expression.body, scope, environment) === TEMPORAL_LEVEL &&
|
|
201
276
|
expression.bounds.every((bound) => getLevel(bound.set, scope, environment) === 0);
|
|
202
|
-
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
277
|
+
const sets = isUnrolled ? getUnrolledElements(expression.bounds, context) : undefined;
|
|
278
|
+
if (isUnrolled && sets) {
|
|
279
|
+
const expanded: ExpandedExpression[] = [];
|
|
280
|
+
forEachBoundElement(expression.bounds, sets, scope, (boundScope) => {
|
|
281
|
+
expanded.push(...expand(expression.body, boundScope, describeRange(expression.body)));
|
|
206
282
|
return false;
|
|
207
283
|
});
|
|
284
|
+
if (expanded.length === 0) throw createTautologyError();
|
|
208
285
|
return expanded;
|
|
209
286
|
}
|
|
210
|
-
return [{ expression, scope }];
|
|
287
|
+
return [{ expression, scope, name }];
|
|
211
288
|
};
|
|
212
289
|
|
|
213
290
|
const bindLetDefinitions = (
|
|
@@ -234,17 +311,19 @@ export const toLiveExpression = (
|
|
|
234
311
|
rootScope: Scope | undefined,
|
|
235
312
|
environment: Environment,
|
|
236
313
|
): LiveExpression => {
|
|
314
|
+
const is174 = environment.runtime.version === "1.7.4";
|
|
237
315
|
const toAtom = (
|
|
238
316
|
expression: Expression,
|
|
239
317
|
scope: Scope | undefined,
|
|
240
318
|
level: number,
|
|
241
319
|
): LiveExpression => {
|
|
242
|
-
|
|
320
|
+
// TLC after 1.7.4 bounds the level of a formula whose parts are constant by the formula's own.
|
|
321
|
+
const atomLevel = level === 0 && !is174 ? getLevel(expression, scope, environment) : level;
|
|
243
322
|
if (atomLevel === 0) {
|
|
244
323
|
const value = evaluate(expression, getConstantContext(environment, scope));
|
|
245
324
|
if (typeof value !== "boolean") {
|
|
246
325
|
throw new TlaEvaluationError(
|
|
247
|
-
`TLC expected a boolean
|
|
326
|
+
`TLC expected a boolean value, but did not find one. ${describeNode(expression)}`,
|
|
248
327
|
);
|
|
249
328
|
}
|
|
250
329
|
return createBoolean(value);
|
|
@@ -262,9 +341,7 @@ export const toLiveExpression = (
|
|
|
262
341
|
scope: Scope | undefined,
|
|
263
342
|
) => {
|
|
264
343
|
if (expansion.depth >= MAXIMUM_EXPANSION_DEPTH) {
|
|
265
|
-
throw
|
|
266
|
-
`TLC overflowed the stack while expanding the temporal formula at ${describeLocation(expression)}`,
|
|
267
|
-
);
|
|
344
|
+
throw createStackOverflowError();
|
|
268
345
|
}
|
|
269
346
|
expansion.depth++;
|
|
270
347
|
const result = convert(body, bodyScope);
|
|
@@ -284,7 +361,9 @@ export const toLiveExpression = (
|
|
|
284
361
|
? lookupScope(scope, name)
|
|
285
362
|
: undefined;
|
|
286
363
|
if (binding?.kind === "Thunk" && definitionThunks.has(binding)) {
|
|
287
|
-
return
|
|
364
|
+
return expandCall(expression, () =>
|
|
365
|
+
expand(binding.expression, binding.scope, expression, scope),
|
|
366
|
+
);
|
|
288
367
|
}
|
|
289
368
|
const operator =
|
|
290
369
|
binding?.kind === "Operator"
|
|
@@ -296,32 +375,104 @@ export const toLiveExpression = (
|
|
|
296
375
|
: resolveGlobalOperator(name, environment);
|
|
297
376
|
if (operator?.kind !== "Closure") throw createCannotHandleError(expression);
|
|
298
377
|
const args = expression.kind === "Apply" ? expression.args : [];
|
|
299
|
-
|
|
378
|
+
const isRecursive =
|
|
379
|
+
!isLocallyResolved(expression) && getDefinition(name, environment)?.isRecursive === true;
|
|
380
|
+
return expandCall(
|
|
381
|
+
expression,
|
|
382
|
+
() => {
|
|
383
|
+
// TLC 1.7.4 evaluates the arguments of an operator it expands.
|
|
384
|
+
if (is174) {
|
|
385
|
+
args
|
|
386
|
+
.filter((arg) => arg.kind !== "Lambda" && arg.kind !== "OperatorReference")
|
|
387
|
+
.forEach((arg) => evaluate(arg, context));
|
|
388
|
+
}
|
|
389
|
+
return expand(
|
|
390
|
+
operator.body,
|
|
391
|
+
bindOperatorArguments(operator, args, context),
|
|
392
|
+
expression,
|
|
393
|
+
scope,
|
|
394
|
+
);
|
|
395
|
+
},
|
|
396
|
+
isRecursive,
|
|
397
|
+
);
|
|
398
|
+
};
|
|
399
|
+
|
|
400
|
+
// TLC takes an application of an operator whose expansion fails for a formula it can't handle,
|
|
401
|
+
// except that TLC after 1.7.4 fails as the expansion of a recursive operator does.
|
|
402
|
+
const expandCall = (
|
|
403
|
+
expression: Expression,
|
|
404
|
+
expandBody: () => LiveExpression,
|
|
405
|
+
isRecursive = false,
|
|
406
|
+
) => {
|
|
407
|
+
try {
|
|
408
|
+
return expandBody();
|
|
409
|
+
} catch (error) {
|
|
410
|
+
const isRethrown = error instanceof TlaStackOverflowError || (isRecursive && !is174);
|
|
411
|
+
if (!(error instanceof TlaEvaluationError) || isRethrown) throw error;
|
|
412
|
+
throw createCannotHandleError(expression);
|
|
413
|
+
}
|
|
300
414
|
};
|
|
301
415
|
|
|
302
416
|
const convertQuantifier = (
|
|
303
417
|
expression: Expression & { kind: "Forall" | "Exists" },
|
|
304
418
|
scope: Scope | undefined,
|
|
305
419
|
) => {
|
|
420
|
+
const level = getLevel(expression, scope, environment);
|
|
306
421
|
const isConstant = expression.bounds.every(
|
|
307
422
|
(bound) => getLevel(bound.set, scope, environment) === 0,
|
|
308
423
|
);
|
|
309
|
-
if (!isConstant)
|
|
424
|
+
if (!isConstant) {
|
|
425
|
+
if (level <= ACTION_LEVEL) return toAtom(expression, scope, level);
|
|
426
|
+
throw createCannotHandleError(expression);
|
|
427
|
+
}
|
|
310
428
|
const operands: LiveExpression[] = [];
|
|
311
|
-
forEachBinding(expression.bounds, getConstantContext(environment, scope), (boundScope) => {
|
|
312
|
-
operands.push(convert(expression.body, boundScope));
|
|
313
|
-
return false;
|
|
314
|
-
});
|
|
315
429
|
const isForall = expression.kind === "Forall";
|
|
430
|
+
// TLC takes a quantified formula whose body fails for one it can't handle, and under \A it adds
|
|
431
|
+
// the message of a failure that isn't an EvalException.
|
|
432
|
+
try {
|
|
433
|
+
forEachBinding(expression.bounds, getConstantContext(environment, scope), (boundScope) => {
|
|
434
|
+
operands.push(convert(expression.body, boundScope));
|
|
435
|
+
return false;
|
|
436
|
+
});
|
|
437
|
+
} catch (error) {
|
|
438
|
+
if (!(error instanceof TlaEvaluationError) || error instanceof TlaStackOverflowError) {
|
|
439
|
+
throw error;
|
|
440
|
+
}
|
|
441
|
+
if (level <= ACTION_LEVEL) return toAtom(expression, scope, level);
|
|
442
|
+
throw createCannotHandleError(
|
|
443
|
+
expression,
|
|
444
|
+
isForall && !isEvalException(error) ? error.message : undefined,
|
|
445
|
+
);
|
|
446
|
+
}
|
|
316
447
|
if (operands.length === 0) return createBoolean(isForall);
|
|
317
|
-
|
|
318
|
-
const level = getLiveLevel(result);
|
|
319
|
-
return level > ACTION_LEVEL ? result : toAtom(expression, scope, level);
|
|
448
|
+
return toWhole(expression, scope, createJunction(isForall ? "And" : "Or", operands));
|
|
320
449
|
};
|
|
321
450
|
|
|
451
|
+
// TLC takes a formula whose translated parts are below temporal level whole, at their level.
|
|
452
|
+
const toWhole = (expression: Expression, scope: Scope | undefined, parts: LiveExpression) => {
|
|
453
|
+
const level = getLiveLevel(parts);
|
|
454
|
+
return level > ACTION_LEVEL ? parts : toAtom(expression, scope, level);
|
|
455
|
+
};
|
|
456
|
+
|
|
457
|
+
// The formulas below temporal level whose parts TLC's Liveness.astToLive translates, as one
|
|
458
|
+
// that is constant, such as a quantifier over the empty set, can make the formula constant.
|
|
459
|
+
const isTranslatedWhole = (expression: Expression) =>
|
|
460
|
+
expression.kind === "Label" ||
|
|
461
|
+
expression.kind === "Let" ||
|
|
462
|
+
expression.kind === "And" ||
|
|
463
|
+
expression.kind === "Or" ||
|
|
464
|
+
expression.kind === "Forall" ||
|
|
465
|
+
expression.kind === "Exists" ||
|
|
466
|
+
expression.kind === "If" ||
|
|
467
|
+
(expression.kind === "Apply" &&
|
|
468
|
+
((expression.operator === "~" && !isLocallyResolved(expression)) ||
|
|
469
|
+
expression.operator === "=>"));
|
|
470
|
+
|
|
322
471
|
const convert = (expression: Expression, scope: Scope | undefined): LiveExpression => {
|
|
323
472
|
const level = getLevel(expression, scope, environment);
|
|
324
|
-
if (level <= ACTION_LEVEL
|
|
473
|
+
if (level <= ACTION_LEVEL && !isTranslatedWhole(expression)) {
|
|
474
|
+
return toAtom(expression, scope, level);
|
|
475
|
+
}
|
|
325
476
|
switch (expression.kind) {
|
|
326
477
|
case "Label":
|
|
327
478
|
return convert(expression.body, scope);
|
|
@@ -342,38 +493,51 @@ export const toLiveExpression = (
|
|
|
342
493
|
);
|
|
343
494
|
}
|
|
344
495
|
if (expression.operator === "~" && !isLocallyResolved(expression)) {
|
|
345
|
-
return createUnary("Not", convert(args[0], scope));
|
|
496
|
+
return toWhole(expression, scope, createUnary("Not", convert(args[0], scope)));
|
|
346
497
|
}
|
|
347
498
|
if (expression.operator === "=>") {
|
|
348
|
-
return
|
|
349
|
-
|
|
350
|
-
|
|
351
|
-
convert(args[1], scope),
|
|
499
|
+
return toWhole(
|
|
500
|
+
expression,
|
|
501
|
+
scope,
|
|
502
|
+
createPair("Or", createUnary("Not", convert(args[0], scope)), convert(args[1], scope)),
|
|
352
503
|
);
|
|
353
504
|
}
|
|
354
505
|
return convertCall(expression, scope);
|
|
355
506
|
}
|
|
356
507
|
case "And":
|
|
357
508
|
case "Or":
|
|
358
|
-
return
|
|
359
|
-
expression
|
|
360
|
-
|
|
509
|
+
return toWhole(
|
|
510
|
+
expression,
|
|
511
|
+
scope,
|
|
512
|
+
createJunction(
|
|
513
|
+
expression.kind,
|
|
514
|
+
expression.operands.map((operand) => convert(operand, scope)),
|
|
515
|
+
),
|
|
361
516
|
);
|
|
362
517
|
case "Forall":
|
|
363
518
|
case "Exists":
|
|
364
519
|
return convertQuantifier(expression, scope);
|
|
365
520
|
case "If": {
|
|
366
|
-
|
|
521
|
+
// TLC 1.7.4 translates both branches whatever the guard.
|
|
522
|
+
if (!is174 && getLevel(expression.condition, scope, environment) === 0) {
|
|
367
523
|
const condition = evaluate(expression.condition, getConstantContext(environment, scope));
|
|
368
524
|
if (typeof condition === "boolean") {
|
|
369
525
|
return convert(condition ? expression.consequent : expression.alternative, scope);
|
|
370
526
|
}
|
|
371
527
|
}
|
|
372
528
|
const condition = convert(expression.condition, scope);
|
|
373
|
-
return
|
|
374
|
-
|
|
375
|
-
|
|
376
|
-
createPair(
|
|
529
|
+
return toWhole(
|
|
530
|
+
expression,
|
|
531
|
+
scope,
|
|
532
|
+
createPair(
|
|
533
|
+
"Or",
|
|
534
|
+
createPair("And", condition, convert(expression.consequent, scope)),
|
|
535
|
+
createPair(
|
|
536
|
+
"And",
|
|
537
|
+
createUnary("Not", condition),
|
|
538
|
+
convert(expression.alternative, scope),
|
|
539
|
+
),
|
|
540
|
+
),
|
|
377
541
|
);
|
|
378
542
|
}
|
|
379
543
|
case "Always":
|
|
@@ -874,7 +874,7 @@ export const mapSelectorArgs = (selector: Selector, map: (arg: Expr) => Expr): S
|
|
|
874
874
|
? { ...selector, args: selector.args.map(map) }
|
|
875
875
|
: selector;
|
|
876
876
|
|
|
877
|
-
|
|
877
|
+
const mapExceptSpecs = (specs: ExceptSpec[], map: (inner: Expr) => Expr): ExceptSpec[] =>
|
|
878
878
|
specs.map((spec) => {
|
|
879
879
|
const value = map(spec.value);
|
|
880
880
|
const trail = spec.trail.map((point): ExceptPoint =>
|
|
@@ -883,7 +883,7 @@ export const mapExceptSpecs = (specs: ExceptSpec[], map: (inner: Expr) => Expr):
|
|
|
883
883
|
return { trail, value };
|
|
884
884
|
});
|
|
885
885
|
|
|
886
|
-
|
|
886
|
+
const mapDefnBody = (definition: Defn, map: (body: Expr) => Expr): Defn =>
|
|
887
887
|
definition.kind === "Operator" || definition.kind === "Bpragma"
|
|
888
888
|
? { ...definition, body: map(definition.body) }
|
|
889
889
|
: definition;
|
package/src/obligation-source.ts
CHANGED
|
@@ -609,6 +609,8 @@ export const createSource = (file: string, text: string, counter: Counter, isExp
|
|
|
609
609
|
);
|
|
610
610
|
case "ExceptAt":
|
|
611
611
|
return at({ kind: "At", isExcept }, { location });
|
|
612
|
+
case "Bracket":
|
|
613
|
+
throw new TlaProofError("Unexpected [ without a function or subscript");
|
|
612
614
|
case "FunctionApplication":
|
|
613
615
|
return at(
|
|
614
616
|
{
|
package/src/parallel-worker.ts
CHANGED
|
@@ -15,10 +15,10 @@ import type {
|
|
|
15
15
|
WorkerMessage,
|
|
16
16
|
} from "./parallel";
|
|
17
17
|
import { getSuccessors, type Successor } from "./successors";
|
|
18
|
-
import { getTlcStringOrder,
|
|
18
|
+
import { getTlcStringOrder, getTlcDeclarationOrder } from "./tlc-order";
|
|
19
19
|
import { OUT_DEGREE_BUCKETS } from "./tlc-summary";
|
|
20
20
|
import { createStateDecoder, createStateEncoder, type EncodedStates } from "./transfer";
|
|
21
|
-
import { getRankedStringCount, setStringOrder, type Value } from "./values";
|
|
21
|
+
import { getRankedStringCount, setStringOrder, setValueVersion, type Value } from "./values";
|
|
22
22
|
|
|
23
23
|
const WORKER_THREADS_MODULE = "node:worker_threads";
|
|
24
24
|
const LOCKED = -1;
|
|
@@ -51,6 +51,7 @@ const run = (start: StartMessage, parent: Port) => {
|
|
|
51
51
|
const loadModule = (name: string) => modules.get(name);
|
|
52
52
|
const classes = new Map(start.classes);
|
|
53
53
|
setStringOrder(getTlcStringOrder(start.source, start.config, loadModule));
|
|
54
|
+
setValueVersion(start.version);
|
|
54
55
|
const startupStrings = getRankedStringCount();
|
|
55
56
|
const specification = createEnvironment(start.config, {
|
|
56
57
|
source: start.source,
|
|
@@ -58,10 +59,14 @@ const run = (start: StartMessage, parent: Port) => {
|
|
|
58
59
|
loadClass: (name) => classes.get(name),
|
|
59
60
|
print: () => {},
|
|
60
61
|
files: { readFile: undefined, writeFile: undefined },
|
|
62
|
+
isTool: start.isTool,
|
|
63
|
+
isTraceRecorded: start.isTraceRecorded,
|
|
64
|
+
isWarningEnabled: start.isWarningEnabled,
|
|
65
|
+
version: start.version,
|
|
61
66
|
});
|
|
62
67
|
const environment = specification.environment;
|
|
63
68
|
const search = createSearch(start.config, environment, () =>
|
|
64
|
-
|
|
69
|
+
getTlcDeclarationOrder(start.source, loadModule, "variable"),
|
|
65
70
|
);
|
|
66
71
|
const nextAction = search?.spec.next;
|
|
67
72
|
if (!search || nextAction === undefined)
|
package/src/parallel.ts
CHANGED
|
@@ -4,8 +4,12 @@ import {
|
|
|
4
4
|
checkSequentially,
|
|
5
5
|
createSearch,
|
|
6
6
|
findAssumptionViolation,
|
|
7
|
+
reportInitialStatesProgress,
|
|
8
|
+
reportStartup,
|
|
7
9
|
type CheckOptions,
|
|
10
|
+
type CheckProgress,
|
|
8
11
|
type CheckResult,
|
|
12
|
+
type InitialStates,
|
|
9
13
|
} from "./check";
|
|
10
14
|
import { parseConfig, type ModelConfig } from "./config";
|
|
11
15
|
import { createEnvironment } from "./environment";
|
|
@@ -23,7 +27,8 @@ import { getInitialStates } from "./successors";
|
|
|
23
27
|
import { getTlcStringOrder, getTlcVariableOrder } from "./tlc-order";
|
|
24
28
|
import { getFingerprintDistance, OUT_DEGREE_BUCKETS } from "./tlc-summary";
|
|
25
29
|
import { createStateEncoder, type EncodedStates } from "./transfer";
|
|
26
|
-
import {
|
|
30
|
+
import type { TlcVersion } from "./tlc-version";
|
|
31
|
+
import { getRankedStringCount, setStringOrder, setValueVersion, type Value } from "./values";
|
|
27
32
|
|
|
28
33
|
const WORKER_THREADS_MODULE = "node:worker_threads";
|
|
29
34
|
|
|
@@ -43,6 +48,10 @@ export interface StartMessage {
|
|
|
43
48
|
index: number;
|
|
44
49
|
ports: (Port | undefined)[];
|
|
45
50
|
seed: EncodedStates;
|
|
51
|
+
isTool: boolean | undefined;
|
|
52
|
+
isTraceRecorded: boolean | undefined;
|
|
53
|
+
isWarningEnabled: boolean | undefined;
|
|
54
|
+
version: TlcVersion | undefined;
|
|
46
55
|
fingerprints: SharedFingerprints;
|
|
47
56
|
requests: Int32Array;
|
|
48
57
|
remaining: Int32Array;
|
|
@@ -101,16 +110,36 @@ const spawnWorker = async (onMessage: (message: WorkerMessage) => void): Promise
|
|
|
101
110
|
};
|
|
102
111
|
|
|
103
112
|
export const check = async (options: CheckOptions): Promise<CheckResult> => {
|
|
104
|
-
const config =
|
|
113
|
+
const config =
|
|
114
|
+
typeof options.config === "string"
|
|
115
|
+
? parseConfig(options.config, options.version)
|
|
116
|
+
: options.config;
|
|
105
117
|
const print = options.onPrint ?? console.log;
|
|
106
118
|
const printed = { count: 0 };
|
|
107
|
-
//
|
|
119
|
+
// What each point the search reports is about, such as the invariant TLC warns about.
|
|
120
|
+
const getKey = (progress: CheckProgress) =>
|
|
121
|
+
[
|
|
122
|
+
progress.kind,
|
|
123
|
+
"name" in progress ? progress.name : "",
|
|
124
|
+
"count" in progress ? progress.count : "",
|
|
125
|
+
"text" in progress ? progress.text : "",
|
|
126
|
+
].join(" ");
|
|
127
|
+
const reported = new Set<string>();
|
|
128
|
+
const report = (progress: CheckProgress) => {
|
|
129
|
+
reported.add(getKey(progress));
|
|
130
|
+
options.onProgress?.(progress);
|
|
131
|
+
};
|
|
132
|
+
// The search on the calling thread prints and reports what this one did while it started, so it
|
|
133
|
+
// skips that.
|
|
108
134
|
const fallBack = () => {
|
|
109
135
|
const skipped = { count: printed.count };
|
|
110
136
|
return checkSequentially({
|
|
111
137
|
...options,
|
|
112
138
|
config,
|
|
113
139
|
onPrint: (text) => (skipped.count-- > 0 ? undefined : print(text)),
|
|
140
|
+
onProgress: (progress) => {
|
|
141
|
+
if (!reported.has(getKey(progress))) options.onProgress?.(progress);
|
|
142
|
+
},
|
|
114
143
|
});
|
|
115
144
|
};
|
|
116
145
|
const count = options.workers ?? 1;
|
|
@@ -137,6 +166,7 @@ export const check = async (options: CheckOptions): Promise<CheckResult> => {
|
|
|
137
166
|
return bytes;
|
|
138
167
|
};
|
|
139
168
|
setStringOrder(getTlcStringOrder(options.source, config, loadModule));
|
|
169
|
+
setValueVersion(options.version);
|
|
140
170
|
const startupStrings = getRankedStringCount();
|
|
141
171
|
const specification = createEnvironment(config, {
|
|
142
172
|
source: options.source,
|
|
@@ -147,10 +177,19 @@ export const check = async (options: CheckOptions): Promise<CheckResult> => {
|
|
|
147
177
|
print(text);
|
|
148
178
|
},
|
|
149
179
|
files: { readFile: options.readFile, writeFile: options.writeFile },
|
|
180
|
+
isTool: options.isTool,
|
|
181
|
+
isTraceRecorded: options.isTraceRecorded,
|
|
182
|
+
isSanyReported: options.isSanyReported,
|
|
183
|
+
isWarningEnabled: options.isWarningEnabled,
|
|
184
|
+
version: options.version,
|
|
150
185
|
});
|
|
186
|
+
reportStartup(specification, config, report);
|
|
151
187
|
const environment = specification.environment;
|
|
152
|
-
const search = createSearch(
|
|
153
|
-
|
|
188
|
+
const search = createSearch(
|
|
189
|
+
config,
|
|
190
|
+
environment,
|
|
191
|
+
() => getTlcVariableOrder(options.source, loadModule),
|
|
192
|
+
report,
|
|
154
193
|
);
|
|
155
194
|
if (findAssumptionViolation(specification.assumptions, environment)) return fallBack();
|
|
156
195
|
if (
|
|
@@ -172,6 +211,7 @@ export const check = async (options: CheckOptions): Promise<CheckResult> => {
|
|
|
172
211
|
distinctStates: 0,
|
|
173
212
|
queuedStates: 0,
|
|
174
213
|
depth: 0,
|
|
214
|
+
initialStates: undefined as InitialStates | undefined,
|
|
175
215
|
outDegrees: Array.from({ length: OUT_DEGREE_BUCKETS }, () => 0),
|
|
176
216
|
};
|
|
177
217
|
const tlcFingerprints: BigInt64Array[] = [];
|
|
@@ -196,6 +236,7 @@ export const check = async (options: CheckOptions): Promise<CheckResult> => {
|
|
|
196
236
|
const seedInitialStates = (init: Expression) => {
|
|
197
237
|
const seeded: Value[][] = [];
|
|
198
238
|
for (const state of getInitialStates(init, environment, search.spec.scope)) {
|
|
239
|
+
reportInitialStatesProgress(statistics.generatedStates, report);
|
|
199
240
|
canonicalize(state);
|
|
200
241
|
statistics.generatedStates++;
|
|
201
242
|
writeStateFingerprint(search.getFingerprintState(state), fingerprint);
|
|
@@ -217,6 +258,7 @@ export const check = async (options: CheckOptions): Promise<CheckResult> => {
|
|
|
217
258
|
return true;
|
|
218
259
|
};
|
|
219
260
|
// The sequential search reports a violation or a failed evaluation in the initial states.
|
|
261
|
+
report({ kind: "initial-states-started" });
|
|
220
262
|
try {
|
|
221
263
|
if (!seedInitialStates(search.spec.init)) return fallBack();
|
|
222
264
|
} catch (error) {
|
|
@@ -225,6 +267,11 @@ export const check = async (options: CheckOptions): Promise<CheckResult> => {
|
|
|
225
267
|
}
|
|
226
268
|
if (getRankedStringCount() !== startupStrings) return fallBack();
|
|
227
269
|
statistics.depth = statistics.generatedStates === 0 ? 0 : 1;
|
|
270
|
+
statistics.initialStates = {
|
|
271
|
+
generated: statistics.generatedStates,
|
|
272
|
+
distinct: statistics.distinctStates,
|
|
273
|
+
};
|
|
274
|
+
report({ kind: "initial-states-computed", initialStates: statistics.initialStates });
|
|
228
275
|
if (statistics.distinctStates === 0) return createSuccess();
|
|
229
276
|
|
|
230
277
|
const reports: WorkerMessage[] = [];
|
|
@@ -266,6 +313,10 @@ export const check = async (options: CheckOptions): Promise<CheckResult> => {
|
|
|
266
313
|
index,
|
|
267
314
|
ports,
|
|
268
315
|
seed,
|
|
316
|
+
isTool: options.isTool,
|
|
317
|
+
isTraceRecorded: options.isTraceRecorded,
|
|
318
|
+
isWarningEnabled: options.isWarningEnabled,
|
|
319
|
+
version: options.version,
|
|
269
320
|
fingerprints: shared.fingerprints,
|
|
270
321
|
requests,
|
|
271
322
|
remaining,
|