tla-ts 0.0.3-dev.31e0776 → 0.0.3-dev.3504663
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +50 -22
- package/dist/index.d.ts +50 -22
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +2 -2
- package/dist/parallel.cjs +1 -1
- package/dist/parallel.js +2 -2
- package/dist/run-cli.cjs +14 -12
- package/dist/run-cli.js +22 -20
- package/dist/transfer.cjs +38 -21
- package/dist/transfer.js +38 -21
- package/package.json +1 -1
- package/src/ast.ts +11 -1
- package/src/builtins.ts +9 -3
- package/src/check.ts +357 -79
- package/src/codegen.ts +6 -3
- package/src/config.ts +224 -170
- package/src/environment.ts +90 -40
- package/src/errors.ts +89 -1
- package/src/evaluate.ts +182 -26
- package/src/exit-codes.ts +22 -3
- package/src/fingerprints.ts +2 -1
- package/src/instances.ts +1 -1
- package/src/levels.ts +173 -37
- package/src/live-check.ts +132 -70
- package/src/liveness.ts +117 -22
- package/src/parallel-worker.ts +2 -2
- package/src/parallel.ts +2 -2
- package/src/parser.ts +71 -19
- package/src/resolve.ts +429 -52
- package/src/run-cli.ts +59 -11
- package/src/sany-lexer.ts +615 -0
- package/src/sany-parse-error.ts +3143 -0
- package/src/spec-description.ts +1 -2
- package/src/standard-modules.ts +54 -45
- package/src/subexpressions.ts +25 -13
- package/src/substitution-levels.ts +38 -17
- package/src/successors.ts +121 -34
- package/src/symmetry.ts +16 -6
- package/src/tableau.ts +51 -24
- package/src/tlc-module.ts +6 -6
- package/src/tlc-modules.ts +4 -0
- package/src/tlc-order.ts +8 -4
- package/src/tlc-random.ts +9 -6
- package/src/tlc-summary.ts +20 -5
- package/src/value-sources.ts +29 -0
- package/src/values.ts +222 -57
package/src/spec-description.ts
CHANGED
|
@@ -7,13 +7,12 @@ import {
|
|
|
7
7
|
} from "./ast";
|
|
8
8
|
import type { ModelConfig } from "./config";
|
|
9
9
|
import type { InstanceAction } from "./environment";
|
|
10
|
-
import { TlaError } from "./errors";
|
|
10
|
+
import { formatRange, TlaError } from "./errors";
|
|
11
11
|
import {
|
|
12
12
|
bindDefinitions,
|
|
13
13
|
bindOperatorArguments,
|
|
14
14
|
evaluate,
|
|
15
15
|
forEachBinding,
|
|
16
|
-
formatRange,
|
|
17
16
|
getDefinition,
|
|
18
17
|
isConstantLevel,
|
|
19
18
|
lookupScope,
|
package/src/standard-modules.ts
CHANGED
|
@@ -11,7 +11,7 @@ import {
|
|
|
11
11
|
getNumber,
|
|
12
12
|
getOperator,
|
|
13
13
|
getSet,
|
|
14
|
-
|
|
14
|
+
getArithmeticSignature,
|
|
15
15
|
getJavaInteger,
|
|
16
16
|
getValue,
|
|
17
17
|
isOutOfRange,
|
|
@@ -40,6 +40,7 @@ import {
|
|
|
40
40
|
isEnumerable,
|
|
41
41
|
isFiniteSet,
|
|
42
42
|
isFunctionValue,
|
|
43
|
+
isReducible,
|
|
43
44
|
isSetValue,
|
|
44
45
|
toFiniteSet,
|
|
45
46
|
unionSorted,
|
|
@@ -47,7 +48,7 @@ import {
|
|
|
47
48
|
createEnumeratedSet,
|
|
48
49
|
EMPTY_SET,
|
|
49
50
|
isEnumeratedSet,
|
|
50
|
-
type
|
|
51
|
+
type ReducibleSet,
|
|
51
52
|
type MixedSetValue,
|
|
52
53
|
type SetOperationValue,
|
|
53
54
|
type SetValue,
|
|
@@ -75,12 +76,6 @@ const unionInTree = (sets: SetValue[], start: number, end: number): SetValue =>
|
|
|
75
76
|
|
|
76
77
|
const SET_OPERATORS: SetOperationValue["operator"][] = ["\\cup", "\\cap", "\\"];
|
|
77
78
|
|
|
78
|
-
type ReducibleSet = SetValue | MixedSetValue | IntervalValue;
|
|
79
|
-
|
|
80
|
-
const isReducible = (value: Value): value is ReducibleSet =>
|
|
81
|
-
typeof value === "object" &&
|
|
82
|
-
(value.kind === "Set" || value.kind === "MixedSet" || value.kind === "Interval");
|
|
83
|
-
|
|
84
79
|
const isMixedSet = (value: Value) => typeof value === "object" && value.kind === "MixedSet";
|
|
85
80
|
|
|
86
81
|
const getReducibleElements = (set: ReducibleSet) =>
|
|
@@ -128,7 +123,7 @@ export const CORE_OPERATORS: Builtin[] = [
|
|
|
128
123
|
),
|
|
129
124
|
defineOperator("\\subseteq", 2, (args) => {
|
|
130
125
|
const left = getSet(args, 0, "\\subseteq");
|
|
131
|
-
const right =
|
|
126
|
+
const right = getValue(args, 1, "\\subseteq");
|
|
132
127
|
const isPowerSets =
|
|
133
128
|
typeof left === "object" &&
|
|
134
129
|
left.kind === "Subset" &&
|
|
@@ -140,8 +135,8 @@ export const CORE_OPERATORS: Builtin[] = [
|
|
|
140
135
|
}),
|
|
141
136
|
...SET_OPERATORS.map((operator) =>
|
|
142
137
|
defineOperator(operator, 2, (args) => {
|
|
143
|
-
const left =
|
|
144
|
-
const right =
|
|
138
|
+
const left = getValue(args, 0, operator);
|
|
139
|
+
const right = getValue(args, 1, operator);
|
|
145
140
|
if (isReducible(left) && isReducible(right) && !isMixedSet(left) && !isMixedSet(right)) {
|
|
146
141
|
if (operator === "\\cup" && isEmptySet(left)) return right;
|
|
147
142
|
const merge =
|
|
@@ -150,7 +145,13 @@ export const CORE_OPERATORS: Builtin[] = [
|
|
|
150
145
|
: operator === "\\cap"
|
|
151
146
|
? intersectSorted
|
|
152
147
|
: differenceSorted;
|
|
153
|
-
|
|
148
|
+
// Merging compares elements across the sets. Where that fails, TLC's element-by-element
|
|
149
|
+
// membership test fails or succeeds on its own.
|
|
150
|
+
try {
|
|
151
|
+
return merge(toFiniteSet(left), toFiniteSet(right));
|
|
152
|
+
} catch (error) {
|
|
153
|
+
if (!(error instanceof TlaEvaluationError)) throw error;
|
|
154
|
+
}
|
|
154
155
|
}
|
|
155
156
|
if (isReducible(left)) return combineReducible(operator, left, right);
|
|
156
157
|
if (operator !== "\\" && isReducible(right)) return combineReducible(operator, right, left);
|
|
@@ -184,51 +185,59 @@ export const CORE_OPERATORS: Builtin[] = [
|
|
|
184
185
|
}),
|
|
185
186
|
];
|
|
186
187
|
|
|
187
|
-
const
|
|
188
|
+
const NEG_SIGNATURE = getArithmeticSignature("Integers", "Neg", "IntValue", 1);
|
|
188
189
|
|
|
189
|
-
|
|
190
|
+
// TLC overrides the operators of Naturals with the Java class of Integers when a spec loads
|
|
191
|
+
// Integers, which names it in their errors.
|
|
192
|
+
const getArithmeticOperators = (javaClass: "Naturals" | "Integers") => {
|
|
193
|
+
const dotDotSignature = getArithmeticSignature(javaClass, "DotDot", "IntervalValue", 2);
|
|
194
|
+
return [
|
|
195
|
+
defineArithmetic(javaClass, "+", "Plus", (left, right) => left + right),
|
|
196
|
+
defineArithmetic(javaClass, "-", "Minus", (left, right) => left - right),
|
|
197
|
+
defineArithmetic(javaClass, "*", "Times", (left, right) => left * right),
|
|
198
|
+
defineArithmetic(javaClass, "^", "Expt", (base, exponent) => {
|
|
199
|
+
if (exponent < 0) {
|
|
200
|
+
throw new TlaModuleError(
|
|
201
|
+
`The second argument of ^ should be a natural number, but instead it is:\n${exponent}`,
|
|
202
|
+
);
|
|
203
|
+
}
|
|
204
|
+
if (base === 0 && exponent === 0) throw new TlaModuleError("0^0 is undefined.");
|
|
205
|
+
return base ** exponent;
|
|
206
|
+
}),
|
|
207
|
+
defineArithmetic(javaClass, "\\div", "Divide", (left, right) => {
|
|
208
|
+
if (right === 0) throw new TlaModuleError("The second argument of \\div is 0.");
|
|
209
|
+
const quotient = Math.floor(left / right);
|
|
210
|
+
if (isOutOfRange(quotient)) throw createOverflowError(`${left} \\div ${right}`);
|
|
211
|
+
return quotient;
|
|
212
|
+
}),
|
|
213
|
+
defineArithmetic(javaClass, "%", "Mod", (left, right) => {
|
|
214
|
+
if (right <= 0) {
|
|
215
|
+
throw new TlaModuleError(
|
|
216
|
+
`The second argument of % should be a positive number, but instead it is:\n${right}`,
|
|
217
|
+
);
|
|
218
|
+
}
|
|
219
|
+
return ((left % right) + right) % right;
|
|
220
|
+
}),
|
|
221
|
+
defineOperator("..", 2, (args) => ({
|
|
222
|
+
kind: "Interval",
|
|
223
|
+
low: getJavaInteger(getValue(args, 0, ".."), dotDotSignature),
|
|
224
|
+
high: getJavaInteger(getValue(args, 1, ".."), dotDotSignature),
|
|
225
|
+
})),
|
|
226
|
+
];
|
|
227
|
+
};
|
|
190
228
|
|
|
191
229
|
const NATURALS_OPERATORS = [
|
|
192
230
|
defineConstant("Nat", { kind: "InfiniteSet", name: "Nat" }),
|
|
193
|
-
|
|
194
|
-
defineArithmetic("-", "Minus", (left, right) => left - right),
|
|
195
|
-
defineArithmetic("*", "Times", (left, right) => left * right),
|
|
196
|
-
defineArithmetic("^", "Expt", (base, exponent) => {
|
|
197
|
-
if (exponent < 0) {
|
|
198
|
-
throw new TlaModuleError(
|
|
199
|
-
`The second argument of ^ should be a natural number, but instead it is:\n${exponent}`,
|
|
200
|
-
);
|
|
201
|
-
}
|
|
202
|
-
if (base === 0 && exponent === 0) throw new TlaModuleError("0^0 is undefined.");
|
|
203
|
-
return base ** exponent;
|
|
204
|
-
}),
|
|
205
|
-
defineArithmetic("\\div", "Divide", (left, right) => {
|
|
206
|
-
if (right === 0) throw new TlaModuleError("The second argument of \\div is 0.");
|
|
207
|
-
const quotient = Math.floor(left / right);
|
|
208
|
-
if (isOutOfRange(quotient)) throw createOverflowError(`${left} \\div ${right}`);
|
|
209
|
-
return quotient;
|
|
210
|
-
}),
|
|
211
|
-
defineArithmetic("%", "Mod", (left, right) => {
|
|
212
|
-
if (right <= 0) {
|
|
213
|
-
throw new TlaModuleError(
|
|
214
|
-
`The second argument of % should be a positive number, but instead it is:\n${right}`,
|
|
215
|
-
);
|
|
216
|
-
}
|
|
217
|
-
return ((left % right) + right) % right;
|
|
218
|
-
}),
|
|
231
|
+
...getArithmeticOperators("Naturals"),
|
|
219
232
|
defineComparison("<", (left, right) => left < right),
|
|
220
233
|
defineComparison(">", (left, right) => left > right),
|
|
221
234
|
defineComparison("<=", (left, right) => left <= right),
|
|
222
235
|
defineComparison(">=", (left, right) => left >= right),
|
|
223
|
-
defineOperator("..", 2, (args) => ({
|
|
224
|
-
kind: "Interval",
|
|
225
|
-
low: getJavaInteger(getValue(args, 0, ".."), DOT_DOT_SIGNATURE),
|
|
226
|
-
high: getJavaInteger(getValue(args, 1, ".."), DOT_DOT_SIGNATURE),
|
|
227
|
-
})),
|
|
228
236
|
];
|
|
229
237
|
|
|
230
238
|
const INTEGERS_OPERATORS = [
|
|
231
239
|
defineConstant("Int", { kind: "InfiniteSet", name: "Int" }),
|
|
240
|
+
...getArithmeticOperators("Integers"),
|
|
232
241
|
defineOperator("-.", 1, (args) => {
|
|
233
242
|
const value = getJavaInteger(getValue(args, 0, "-"), NEG_SIGNATURE);
|
|
234
243
|
if (isOutOfRange(-value)) throw createOverflowError(`-${value}`);
|
package/src/subexpressions.ts
CHANGED
|
@@ -11,7 +11,13 @@ import {
|
|
|
11
11
|
} from "./ast";
|
|
12
12
|
import { TlaSyntaxError } from "./errors";
|
|
13
13
|
import { getSourceName, mapChildren, mapDefinition } from "./instances";
|
|
14
|
-
import {
|
|
14
|
+
import {
|
|
15
|
+
getArity,
|
|
16
|
+
getBoundNames,
|
|
17
|
+
getOperandIndex,
|
|
18
|
+
getPatternNames,
|
|
19
|
+
LOCAL_RESOLUTION,
|
|
20
|
+
} from "./resolve";
|
|
15
21
|
|
|
16
22
|
type Lookup = (name: string) => Definition | undefined;
|
|
17
23
|
|
|
@@ -37,12 +43,6 @@ const getBoundSets = (bounds: Bound[]) =>
|
|
|
37
43
|
.filter((bound, index) => index === 0 || bounds[index - 1].set !== bound.set)
|
|
38
44
|
.map((bound) => bound.set);
|
|
39
45
|
|
|
40
|
-
const getOperandIndex = (operand: number | "<<" | ">>", count: number) => {
|
|
41
|
-
if (typeof operand === "number") return operand >= 1 && operand <= count ? operand - 1 : -1;
|
|
42
|
-
if (operand === "<<") return count > 0 ? 0 : -1;
|
|
43
|
-
return count === 2 ? 1 : -1;
|
|
44
|
-
};
|
|
45
|
-
|
|
46
46
|
const getOperands = (expression: Expression): Expression[] | undefined => {
|
|
47
47
|
switch (expression.kind) {
|
|
48
48
|
case "Apply":
|
|
@@ -393,15 +393,22 @@ const containsReference = (expression: Expression): boolean =>
|
|
|
393
393
|
(expression.kind === "Apply" && expression.operator.includes("!")) ||
|
|
394
394
|
getChildren(expression).some(containsReference);
|
|
395
395
|
|
|
396
|
-
|
|
396
|
+
// A reference into a theorem whose statement is an ASSUME/PROVE stays for name resolution to check.
|
|
397
|
+
const resolveSubexpressions = (
|
|
398
|
+
expression: Expression,
|
|
399
|
+
lookup: Lookup,
|
|
400
|
+
goals: ReadonlySet<string>,
|
|
401
|
+
): Expression => {
|
|
397
402
|
if (!containsReference(expression)) return expression;
|
|
398
403
|
if (expression.kind === "Let") {
|
|
399
404
|
const local: Lookup = (name) =>
|
|
400
405
|
expression.definitions.find((definition) => definition.name === name) ?? lookup(name);
|
|
401
|
-
return mapChildren(expression, (child) => resolveSubexpressions(child, local));
|
|
406
|
+
return mapChildren(expression, (child) => resolveSubexpressions(child, local, goals));
|
|
402
407
|
}
|
|
403
|
-
const mapped = mapChildren(expression, (child) => resolveSubexpressions(child, lookup));
|
|
408
|
+
const mapped = mapChildren(expression, (child) => resolveSubexpressions(child, lookup, goals));
|
|
404
409
|
if (mapped.kind === "Subexpression") {
|
|
410
|
+
const first = mapped.selectors[0];
|
|
411
|
+
if (first.kind === "Name" && goals.has(first.name)) return mapped;
|
|
405
412
|
return selectSubexpression(mapped.selectors, lookup, mapped.location, []);
|
|
406
413
|
}
|
|
407
414
|
const name =
|
|
@@ -425,7 +432,7 @@ export const resolveInstanceSubexpressions = (instance: Instance, module: Module
|
|
|
425
432
|
...instance,
|
|
426
433
|
substitutions: instance.substitutions.map((substitution) => ({
|
|
427
434
|
name: substitution.name,
|
|
428
|
-
expression: resolveSubexpressions(substitution.expression, lookup),
|
|
435
|
+
expression: resolveSubexpressions(substitution.expression, lookup, new Set()),
|
|
429
436
|
})),
|
|
430
437
|
};
|
|
431
438
|
};
|
|
@@ -436,14 +443,19 @@ export const resolveModuleSubexpressions = (module: Module, available: Definitio
|
|
|
436
443
|
module.definitions.some((definition) => containsReference(definition.body)) ||
|
|
437
444
|
module.assumptions.some((assumption) => containsReference(assumption.expression));
|
|
438
445
|
if (!hasReferences) return module;
|
|
446
|
+
const goals = new Set(
|
|
447
|
+
module.theorems.flatMap((theorem) =>
|
|
448
|
+
theorem.name !== undefined && theorem.statement.kind === "AssumeProve" ? [theorem.name] : [],
|
|
449
|
+
),
|
|
450
|
+
);
|
|
439
451
|
return {
|
|
440
452
|
...module,
|
|
441
453
|
definitions: module.definitions.map((definition) =>
|
|
442
|
-
mapDefinition(definition, (child) => resolveSubexpressions(child, lookup)),
|
|
454
|
+
mapDefinition(definition, (child) => resolveSubexpressions(child, lookup, goals)),
|
|
443
455
|
),
|
|
444
456
|
assumptions: module.assumptions.map((assumption) => ({
|
|
445
457
|
...assumption,
|
|
446
|
-
expression: resolveSubexpressions(assumption.expression, lookup),
|
|
458
|
+
expression: resolveSubexpressions(assumption.expression, lookup, goals),
|
|
447
459
|
})),
|
|
448
460
|
};
|
|
449
461
|
};
|
|
@@ -1,6 +1,8 @@
|
|
|
1
|
-
import type { Declaration, Definition, Expression, SourceLocation } from "./ast";
|
|
2
|
-
import {
|
|
1
|
+
import type { Declaration, Definition, Expression, SourceLocation, Theorem } from "./ast";
|
|
2
|
+
import { createSanyError, formatRange } from "./errors";
|
|
3
3
|
import {
|
|
4
|
+
ACTION_LEVEL,
|
|
5
|
+
analyzeAssumeProve,
|
|
4
6
|
createLevelAnalyzer,
|
|
5
7
|
getArgumentKey,
|
|
6
8
|
MAX_LEVEL,
|
|
@@ -24,6 +26,7 @@ interface ModuleContext {
|
|
|
24
26
|
variables: string[];
|
|
25
27
|
definitions: Definition[];
|
|
26
28
|
assumptions: Expression[];
|
|
29
|
+
theorems: Theorem[];
|
|
27
30
|
getDefinition: (name: string) => Definition | undefined;
|
|
28
31
|
}
|
|
29
32
|
|
|
@@ -46,10 +49,7 @@ interface Substituted {
|
|
|
46
49
|
const getMaxLevel = (operator: OperatorLevels, index: number) =>
|
|
47
50
|
operator.maxLevels[index] ?? MAX_LEVEL;
|
|
48
51
|
|
|
49
|
-
export const
|
|
50
|
-
checks: InstanceCheck[],
|
|
51
|
-
getModule: (name: string) => ModuleContext,
|
|
52
|
-
) => {
|
|
52
|
+
export const createInstanceChecker = (getModule: (name: string) => ModuleContext) => {
|
|
53
53
|
const analyzers = new Map<string, ReturnType<typeof createLevelAnalyzer>>();
|
|
54
54
|
const getAnalyzer = (name: string) => {
|
|
55
55
|
const cached = analyzers.get(name);
|
|
@@ -101,17 +101,38 @@ export const checkInstances = (
|
|
|
101
101
|
definition.formals.every((formal) => formal.name !== operator && formal.name !== param),
|
|
102
102
|
),
|
|
103
103
|
);
|
|
104
|
+
const addAssumedLevels = (data: ReturnType<typeof analyzeAssumeProve>) => {
|
|
105
|
+
addLevels(data, () => true);
|
|
106
|
+
module.constants.forEach((constant) => {
|
|
107
|
+
if (data.params.has(constant.name)) {
|
|
108
|
+
putConstraint(levels.constraints, constant.name, ACTION_LEVEL);
|
|
109
|
+
}
|
|
110
|
+
});
|
|
111
|
+
};
|
|
104
112
|
module.assumptions.forEach((assumption) =>
|
|
105
|
-
|
|
113
|
+
addAssumedLevels(analyzer.analyze(assumption, new Map())),
|
|
114
|
+
);
|
|
115
|
+
module.theorems.forEach((theorem) =>
|
|
116
|
+
theorem.statement.kind === "AssumeProve"
|
|
117
|
+
? addAssumedLevels(analyzeAssumeProve(theorem.statement, new Map(), analyzer))
|
|
118
|
+
: addLevels(analyzer.analyze(theorem.statement, new Map()), () => true),
|
|
106
119
|
);
|
|
107
120
|
moduleLevels.set(name, levels);
|
|
108
121
|
return levels;
|
|
109
122
|
};
|
|
110
123
|
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
const
|
|
124
|
+
return (check: InstanceCheck) => {
|
|
125
|
+
const errors = new Map<string, { location: string; message: string }>();
|
|
126
|
+
// SANY reports each error at the whole instance.
|
|
127
|
+
const location = formatRange(
|
|
128
|
+
check.location.range ?? {
|
|
129
|
+
module: check.instancer,
|
|
130
|
+
start: check.location,
|
|
131
|
+
end: check.location,
|
|
132
|
+
},
|
|
133
|
+
);
|
|
134
|
+
const addMessage = (message: string) =>
|
|
135
|
+
errors.set(`${location}\n${message}`, { location, message });
|
|
115
136
|
const instancee = getModule(check.module);
|
|
116
137
|
const levels = getModuleLevels(check.module);
|
|
117
138
|
const analyzer = getAnalyzer(check.instancer);
|
|
@@ -141,14 +162,14 @@ export const checkInstances = (
|
|
|
141
162
|
];
|
|
142
163
|
});
|
|
143
164
|
const getLevelMessage = (name: string, level: number) =>
|
|
144
|
-
`Level error in instantiating module '${check.module}'
|
|
165
|
+
`Level error in instantiating module '${check.module}':\nThe level of the expression or operator substituted for '${name}' \nmust be at most ${level}.`;
|
|
145
166
|
substituted.forEach((item) => {
|
|
146
167
|
if (!levels.isConstant && item.level > item.maximumLevel) {
|
|
147
168
|
addMessage(getLevelMessage(item.name, item.maximumLevel));
|
|
148
169
|
}
|
|
149
170
|
if (!item.isLeibniz) {
|
|
150
171
|
addMessage(
|
|
151
|
-
`Error in instantiating module '${check.module}'
|
|
172
|
+
`Error in instantiating module '${check.module}':\n A non-Leibniz operator substituted for '${item.name}'.`,
|
|
152
173
|
);
|
|
153
174
|
}
|
|
154
175
|
});
|
|
@@ -162,7 +183,7 @@ export const checkInstances = (
|
|
|
162
183
|
const minimum = levels.argConstraints.get(getArgumentKey(item.name, index));
|
|
163
184
|
if (minimum !== undefined && getMaxLevel(operator, index) < minimum) {
|
|
164
185
|
addMessage(
|
|
165
|
-
`Level error in instantiating module '${check.module}'
|
|
186
|
+
`Level error in instantiating module '${check.module}':\nThe level of the argument ${index + 1} of the operator ${operator.name} \nmust be at least ${minimum}.`,
|
|
166
187
|
);
|
|
167
188
|
}
|
|
168
189
|
});
|
|
@@ -175,10 +196,10 @@ export const checkInstances = (
|
|
|
175
196
|
const maximum = getMaxLevel(operator, parameter.index);
|
|
176
197
|
if (argument.level > maximum) {
|
|
177
198
|
addMessage(
|
|
178
|
-
`Level error when instantiating module '${check.module}'
|
|
199
|
+
`Level error when instantiating module '${check.module}':\nThe level of the argument ${parameter.index} of the operator ${parameter.operator}' \nmust be at most ${maximum}.`,
|
|
179
200
|
);
|
|
180
201
|
}
|
|
181
202
|
});
|
|
182
|
-
|
|
183
|
-
|
|
203
|
+
if (errors.size > 0) throw createSanyError([...errors.values()]);
|
|
204
|
+
};
|
|
184
205
|
};
|
package/src/successors.ts
CHANGED
|
@@ -7,7 +7,12 @@ import {
|
|
|
7
7
|
type QuantifierExpression,
|
|
8
8
|
} from "./ast";
|
|
9
9
|
import { getReadVariables } from "./dependencies";
|
|
10
|
-
import {
|
|
10
|
+
import {
|
|
11
|
+
TlaEvaluationError,
|
|
12
|
+
TlaIllegalStateError,
|
|
13
|
+
TlaIncompleteStateError,
|
|
14
|
+
TlaUnassignedError,
|
|
15
|
+
} from "./errors";
|
|
11
16
|
import { EXIT_STATUS, setExitCode } from "./exit-codes";
|
|
12
17
|
import {
|
|
13
18
|
describeLocation,
|
|
@@ -18,6 +23,7 @@ import {
|
|
|
18
23
|
bindValue,
|
|
19
24
|
compileArgumentScope,
|
|
20
25
|
evaluate,
|
|
26
|
+
getEntryEvaluator,
|
|
21
27
|
expectBoolean,
|
|
22
28
|
forEachBinding,
|
|
23
29
|
getBoundsDomain,
|
|
@@ -29,6 +35,7 @@ import {
|
|
|
29
35
|
resolveGlobalOperator,
|
|
30
36
|
type Context,
|
|
31
37
|
type Environment,
|
|
38
|
+
type Evaluator,
|
|
32
39
|
type Scope,
|
|
33
40
|
type State,
|
|
34
41
|
} from "./evaluate";
|
|
@@ -51,6 +58,7 @@ export interface Successor {
|
|
|
51
58
|
interface Run {
|
|
52
59
|
environment: Environment;
|
|
53
60
|
isInit: boolean;
|
|
61
|
+
isEnabled: boolean;
|
|
54
62
|
current: Value[] | undefined;
|
|
55
63
|
isStopped: boolean;
|
|
56
64
|
}
|
|
@@ -87,25 +95,54 @@ const assign = (partial: State, index: number, value: Value) => {
|
|
|
87
95
|
return copy;
|
|
88
96
|
};
|
|
89
97
|
|
|
90
|
-
|
|
91
|
-
|
|
98
|
+
// TLC's Tool.getInitStates and Tool.getNextStates report a value where they expect a formula.
|
|
99
|
+
const expectFormula = (expression: Expression, value: Value, isInit: boolean) => {
|
|
92
100
|
if (typeof value === "boolean") return value;
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
101
|
+
throw new TlaEvaluationError(
|
|
102
|
+
`In computing ${isInit ? "initial" : "next"} states, TLC expected a boolean expression,\nbut instead found ${formatValue(value)}.\n${describeRange(expression)}`,
|
|
103
|
+
);
|
|
104
|
+
};
|
|
105
|
+
|
|
106
|
+
const holds = (expression: Expression, context: Context, value = evaluate(expression, context)) => {
|
|
107
|
+
// TLC rejects a number in the next-state relation when it splits the relation into actions.
|
|
108
|
+
if (context.next !== undefined && expression.kind === "Number") {
|
|
109
|
+
throw setExitCode(
|
|
110
|
+
new TlaEvaluationError(
|
|
111
|
+
`The next state relation is not a boolean expression.\n${expression.text ?? expression.value}`,
|
|
112
|
+
),
|
|
113
|
+
EXIT_STATUS.error,
|
|
114
|
+
);
|
|
98
115
|
}
|
|
116
|
+
return expectFormula(expression, value, context.next === undefined);
|
|
99
117
|
};
|
|
100
118
|
|
|
101
119
|
const isAssignmentOperator = (operator: string) =>
|
|
102
120
|
operator === "=" || operator === "\\in" || operator === "\\subseteq";
|
|
103
121
|
|
|
122
|
+
const tracedRunners = new WeakMap<Environment, WeakMap<Expression, Runner>[]>();
|
|
123
|
+
|
|
124
|
+
const getRunners = (environment: Environment, isInit: boolean) => {
|
|
125
|
+
if (!environment.trace) return isInit ? initRunners : nextRunners;
|
|
126
|
+
const runners = tracedRunners.get(environment) ?? [new WeakMap(), new WeakMap()];
|
|
127
|
+
tracedRunners.set(environment, runners);
|
|
128
|
+
return runners[isInit ? 0 : 1];
|
|
129
|
+
};
|
|
130
|
+
|
|
104
131
|
const getRunner = (expression: Expression, environment: Environment, isInit: boolean): Runner => {
|
|
105
|
-
const runners = isInit
|
|
132
|
+
const runners = getRunners(environment, isInit);
|
|
106
133
|
const cached = runners.get(expression);
|
|
107
134
|
if (cached) return cached;
|
|
108
|
-
const
|
|
135
|
+
const compiled = compileAction(expression, environment, isInit);
|
|
136
|
+
const trace = environment.trace;
|
|
137
|
+
// TLC's CallStackTool keeps an action's expression on the stack while the rest of the action runs.
|
|
138
|
+
const runner: Runner = trace
|
|
139
|
+
? (run, scope, partial, action, isFixed, onComplete) => {
|
|
140
|
+
const depth = trace.length;
|
|
141
|
+
trace.push(expression);
|
|
142
|
+
compiled(run, scope, partial, action, isFixed, onComplete);
|
|
143
|
+
trace.length = depth;
|
|
144
|
+
}
|
|
145
|
+
: compiled;
|
|
109
146
|
runners.set(expression, runner);
|
|
110
147
|
return runner;
|
|
111
148
|
};
|
|
@@ -189,6 +226,23 @@ const getUnchangedIndices = (
|
|
|
189
226
|
return getUnchangedIndices(definition.body, environment, visited);
|
|
190
227
|
};
|
|
191
228
|
|
|
229
|
+
// TLC's CallStackTool keeps each expression that UNCHANGED takes apart on the stack.
|
|
230
|
+
const getUnchangedFrames = (expression: Expression, environment: Environment): Expression[] => {
|
|
231
|
+
if (expression.kind === "Tuple") {
|
|
232
|
+
return [
|
|
233
|
+
expression,
|
|
234
|
+
...expression.elements.flatMap((element) => getUnchangedFrames(element, environment)),
|
|
235
|
+
];
|
|
236
|
+
}
|
|
237
|
+
const definition =
|
|
238
|
+
expression.kind === "Identifier" && !environment.variableIndex.has(expression.name)
|
|
239
|
+
? getZeroArityBody(expression.name, environment)
|
|
240
|
+
: undefined;
|
|
241
|
+
return definition
|
|
242
|
+
? [expression, ...getUnchangedFrames(definition.body, environment)]
|
|
243
|
+
: [expression];
|
|
244
|
+
};
|
|
245
|
+
|
|
192
246
|
const ACTION_KINDS = new Set([
|
|
193
247
|
"Label",
|
|
194
248
|
"And",
|
|
@@ -320,6 +374,8 @@ const compileConjunction = (
|
|
|
320
374
|
isInit: boolean,
|
|
321
375
|
): Runner => {
|
|
322
376
|
const conjuncts = operands.map((operand) => toConjunct(operand, environment, isInit));
|
|
377
|
+
const evaluators: (Evaluator | undefined)[] = conjuncts.map(() => undefined);
|
|
378
|
+
const trace = environment.trace;
|
|
323
379
|
const runFrom = (
|
|
324
380
|
start: number,
|
|
325
381
|
run: Run,
|
|
@@ -340,14 +396,25 @@ const compileConjunction = (
|
|
|
340
396
|
return;
|
|
341
397
|
}
|
|
342
398
|
const conjunct = conjuncts[index];
|
|
399
|
+
if (trace) {
|
|
400
|
+
trace.push(conjunct.expression);
|
|
401
|
+
if (conjunct.expression.kind === "Unchanged") {
|
|
402
|
+
trace.push(...getUnchangedFrames(conjunct.expression.expression, environment));
|
|
403
|
+
}
|
|
404
|
+
}
|
|
343
405
|
if (conjunct.kind === "Guard") {
|
|
344
406
|
context ??= getContext(run, scope, current);
|
|
345
|
-
|
|
407
|
+
const evaluator = (evaluators[index] ??= getEntryEvaluator(
|
|
408
|
+
conjunct.expression,
|
|
409
|
+
environment,
|
|
410
|
+
));
|
|
411
|
+
if (!holds(conjunct.expression, context, evaluator(context))) return;
|
|
346
412
|
continue;
|
|
347
413
|
}
|
|
348
414
|
if (conjunct.kind === "Assign") {
|
|
349
415
|
context ??= getContext(run, scope, current);
|
|
350
|
-
const
|
|
416
|
+
const evaluator = (evaluators[index] ??= getEntryEvaluator(conjunct.value, environment));
|
|
417
|
+
const value = evaluator(context);
|
|
351
418
|
const assigned = current[conjunct.index];
|
|
352
419
|
if (assigned === undefined) {
|
|
353
420
|
current = assign(current, conjunct.index, value);
|
|
@@ -384,10 +451,7 @@ const compileConjunction = (
|
|
|
384
451
|
};
|
|
385
452
|
|
|
386
453
|
const holdsInInit = (expression: Expression, context: Context) =>
|
|
387
|
-
|
|
388
|
-
evaluate(expression, context),
|
|
389
|
-
`the initial predicate at ${describeLocation(expression)}`,
|
|
390
|
-
);
|
|
454
|
+
expectFormula(expression, evaluate(expression, context), true);
|
|
391
455
|
|
|
392
456
|
const compileGuard =
|
|
393
457
|
(expression: Expression): Runner =>
|
|
@@ -412,7 +476,7 @@ const compileMembership = (
|
|
|
412
476
|
expression.operator === "\\subseteq" ? { kind: "Subset", base: evaluated } : evaluated;
|
|
413
477
|
if (!isEnumerable(value)) {
|
|
414
478
|
throw new TlaEvaluationError(
|
|
415
|
-
`In computing next states, the right side of \\
|
|
479
|
+
`In computing ${run.isInit ? "initial" : "next"} states, the right side of \\IN is not enumerable.\n${describeRange(expression)}`,
|
|
416
480
|
);
|
|
417
481
|
}
|
|
418
482
|
const elements = getStreamedElements(value);
|
|
@@ -756,7 +820,8 @@ const compileAction = (
|
|
|
756
820
|
}
|
|
757
821
|
};
|
|
758
822
|
}
|
|
759
|
-
const hoisted =
|
|
823
|
+
const hoisted =
|
|
824
|
+
isInit || environment.trace ? undefined : getHoistedGuards(expression, environment);
|
|
760
825
|
if (hoisted) {
|
|
761
826
|
const rest = compileConjunction(hoisted.rest, environment, isInit);
|
|
762
827
|
return (run, scope, partial, action, isFixed, onComplete) => {
|
|
@@ -859,7 +924,7 @@ const compileAction = (
|
|
|
859
924
|
const body = arm?.body ?? other;
|
|
860
925
|
if (!body)
|
|
861
926
|
throw new TlaEvaluationError(
|
|
862
|
-
|
|
927
|
+
`In computing ${run.isInit ? "initial" : "next"} states, TLC encountered a CASE with no conditions true.\n${describeRange(expression)}`,
|
|
863
928
|
);
|
|
864
929
|
body(run, scope, partial, action, isFixed, onComplete);
|
|
865
930
|
};
|
|
@@ -891,8 +956,17 @@ const compileAction = (
|
|
|
891
956
|
const unchanged = getUnchangedWrapper(expression.subscript);
|
|
892
957
|
return (run, scope, partial, action, isFixed, onComplete) =>
|
|
893
958
|
body(run, scope, partial, action, isFixed, (nextPartial, nextAction) => {
|
|
894
|
-
|
|
895
|
-
|
|
959
|
+
// ENABLED evaluates the subscript on the successor that the action specifies. TLC names
|
|
960
|
+
// a variable that the action leaves without a value.
|
|
961
|
+
try {
|
|
962
|
+
if (!holds(unchanged, getContext(run, scope, nextPartial)))
|
|
963
|
+
onComplete(nextPartial, nextAction);
|
|
964
|
+
} catch (error) {
|
|
965
|
+
if (!run.isEnabled || !(error instanceof TlaUnassignedError)) throw error;
|
|
966
|
+
throw new TlaEvaluationError(
|
|
967
|
+
`The action formula A appearing in a WF_v(A) or SF_v(A) operator does not specify the primed value of the variable ${error.variable} occurring in the state formula v.\n`,
|
|
968
|
+
);
|
|
969
|
+
}
|
|
896
970
|
});
|
|
897
971
|
}
|
|
898
972
|
case "BoxAction":
|
|
@@ -969,7 +1043,13 @@ export const isEnabled = (expression: Expression, context: Context): boolean =>
|
|
|
969
1043
|
);
|
|
970
1044
|
}
|
|
971
1045
|
const environment = context.environment;
|
|
972
|
-
const run: Run = {
|
|
1046
|
+
const run: Run = {
|
|
1047
|
+
environment,
|
|
1048
|
+
isInit: false,
|
|
1049
|
+
isEnabled: true,
|
|
1050
|
+
current: state,
|
|
1051
|
+
isStopped: false,
|
|
1052
|
+
};
|
|
973
1053
|
// TLC stops computing ENABLED at the first successor, so it skips the rest of the action.
|
|
974
1054
|
getRunner(expression, environment, false)(
|
|
975
1055
|
run,
|
|
@@ -990,7 +1070,13 @@ export const forEachInitialState = (
|
|
|
990
1070
|
onState: (state: Value[]) => boolean,
|
|
991
1071
|
scope?: Scope,
|
|
992
1072
|
) => {
|
|
993
|
-
const run: Run = {
|
|
1073
|
+
const run: Run = {
|
|
1074
|
+
environment,
|
|
1075
|
+
isInit: true,
|
|
1076
|
+
isEnabled: false,
|
|
1077
|
+
current: undefined,
|
|
1078
|
+
isStopped: false,
|
|
1079
|
+
};
|
|
994
1080
|
getRunner(expression, environment, true)(
|
|
995
1081
|
run,
|
|
996
1082
|
scope,
|
|
@@ -1000,14 +1086,7 @@ export const forEachInitialState = (
|
|
|
1000
1086
|
(partial) => {
|
|
1001
1087
|
if (run.isStopped) return;
|
|
1002
1088
|
if (!isComplete(partial)) {
|
|
1003
|
-
|
|
1004
|
-
// an evaluation failure.
|
|
1005
|
-
throw setExitCode(
|
|
1006
|
-
new TlaEvaluationError(
|
|
1007
|
-
`The initial predicate does not assign ${getMissingVariables(partial, environment).join(", ")}`,
|
|
1008
|
-
),
|
|
1009
|
-
EXIT_STATUS.error,
|
|
1010
|
-
);
|
|
1089
|
+
throw setExitCode(new TlaIllegalStateError(partial), EXIT_STATUS.error);
|
|
1011
1090
|
}
|
|
1012
1091
|
run.isStopped = onState(partial);
|
|
1013
1092
|
},
|
|
@@ -1039,7 +1118,13 @@ export const forEachSuccessor = (
|
|
|
1039
1118
|
onSuccessor: (successor: Successor) => boolean,
|
|
1040
1119
|
scope?: Scope,
|
|
1041
1120
|
) => {
|
|
1042
|
-
const run: Run = {
|
|
1121
|
+
const run: Run = {
|
|
1122
|
+
environment,
|
|
1123
|
+
isInit: false,
|
|
1124
|
+
isEnabled: false,
|
|
1125
|
+
current: state,
|
|
1126
|
+
isStopped: false,
|
|
1127
|
+
};
|
|
1043
1128
|
const counter = { successors: 0 };
|
|
1044
1129
|
getRunner(expression, environment, false)(
|
|
1045
1130
|
run,
|
|
@@ -1050,8 +1135,10 @@ export const forEachSuccessor = (
|
|
|
1050
1135
|
(partial, action) => {
|
|
1051
1136
|
if (run.isStopped) return;
|
|
1052
1137
|
if (!isComplete(partial)) {
|
|
1053
|
-
throw new
|
|
1054
|
-
|
|
1138
|
+
throw new TlaIncompleteStateError(
|
|
1139
|
+
partial,
|
|
1140
|
+
action,
|
|
1141
|
+
getMissingVariables(partial, environment).sort(),
|
|
1055
1142
|
);
|
|
1056
1143
|
}
|
|
1057
1144
|
counter.successors++;
|