tla-ts 0.0.2 → 0.0.3-dev.037ac3b
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/README.md +78 -12
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +60 -1
- package/dist/index.d.ts +60 -1
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +2 -2
- package/dist/parallel-worker.js +2 -2
- package/dist/parallel.cjs +1 -1
- package/dist/parallel.js +2 -2
- package/dist/run-cli.cjs +21 -2
- package/dist/run-cli.js +21 -2
- package/dist/transfer.cjs +27 -15
- package/dist/transfer.js +27 -15
- package/package.json +3 -1
- package/src/ast.ts +134 -4
- package/src/check.ts +280 -80
- package/src/cli-options.ts +64 -0
- package/src/codegen.ts +9 -19
- package/src/dependencies.ts +2 -2
- package/src/environment.ts +75 -16
- package/src/errors.ts +46 -3
- package/src/evaluate.ts +88 -143
- package/src/exit-codes.ts +21 -43
- package/src/fingerprints.ts +46 -11
- package/src/instances.ts +15 -14
- package/src/levels.ts +8 -8
- package/src/lexer.ts +11 -2
- package/src/live-check.ts +692 -0
- package/src/liveness.ts +54 -535
- package/src/obligation-action.ts +384 -0
- package/src/obligation-anon.ts +575 -0
- package/src/obligation-deref.ts +637 -0
- package/src/obligation-expression.ts +1060 -0
- package/src/obligation-format.ts +406 -0
- package/src/obligation-generate.ts +1074 -0
- package/src/obligation-levels.ts +329 -0
- package/src/obligation-module.ts +1042 -0
- package/src/obligation-printer.ts +889 -0
- package/src/obligation-proof.ts +76 -0
- package/src/obligation-source.ts +1084 -0
- package/src/obligation-tuples.ts +184 -0
- package/src/obligations.ts +316 -0
- package/src/parallel-worker.ts +166 -210
- package/src/parallel.ts +76 -35
- package/src/parser.ts +297 -53
- package/src/resolve.ts +16 -15
- package/src/run-cli.ts +353 -40
- package/src/runtime.ts +3 -1
- package/src/spec-description.ts +18 -6
- package/src/standard-levels.ts +3 -3
- package/src/standard-modules.ts +2 -7
- package/src/state-graph.ts +157 -0
- package/src/subexpressions.ts +10 -10
- package/src/successors.ts +77 -13
- package/src/symmetry.ts +14 -2
- package/src/tableau.ts +50 -23
- package/src/tlc-ext.ts +29 -12
- package/src/tlc-module.ts +9 -28
- package/src/tlc-order.ts +17 -3
- package/src/tlc-random.ts +9 -6
- package/src/tlc-summary.ts +20 -5
- package/src/transfer.ts +22 -1
- package/src/values.ts +118 -34
package/src/evaluate.ts
CHANGED
|
@@ -1,14 +1,16 @@
|
|
|
1
|
-
import
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
1
|
+
import {
|
|
2
|
+
getChildren,
|
|
3
|
+
isLocallyResolved,
|
|
4
|
+
type Bound,
|
|
5
|
+
type BoundPattern,
|
|
6
|
+
type DecimalExpression,
|
|
7
|
+
type Definition,
|
|
8
|
+
type Expression,
|
|
9
|
+
type FunctionDefinition,
|
|
10
|
+
type NumberExpression,
|
|
11
|
+
type OperatorParam,
|
|
12
|
+
type RecordField,
|
|
13
|
+
type SourceRange,
|
|
12
14
|
} from "./ast";
|
|
13
15
|
import { getKindString } from "./builtins";
|
|
14
16
|
import { TlaEvaluationError } from "./errors";
|
|
@@ -34,11 +36,11 @@ import {
|
|
|
34
36
|
getIntervalElements,
|
|
35
37
|
getSequenceElements,
|
|
36
38
|
getValueHash,
|
|
37
|
-
isEnumerable,
|
|
38
39
|
isFunctionValue,
|
|
39
40
|
isOverriddenSet,
|
|
40
41
|
isSameValue,
|
|
41
42
|
markLambdaFunction,
|
|
43
|
+
isReducible,
|
|
42
44
|
isSetValue,
|
|
43
45
|
MAXIMUM_INTEGER,
|
|
44
46
|
MINIMUM_INTEGER,
|
|
@@ -262,96 +264,6 @@ export const expectBoolean = (value: Value, description: string) => {
|
|
|
262
264
|
return value;
|
|
263
265
|
};
|
|
264
266
|
|
|
265
|
-
export const getChildren = (expression: Expression): Expression[] => {
|
|
266
|
-
switch (expression.kind) {
|
|
267
|
-
case "Number":
|
|
268
|
-
case "Decimal":
|
|
269
|
-
case "String":
|
|
270
|
-
case "Identifier":
|
|
271
|
-
case "OperatorReference":
|
|
272
|
-
case "ExceptAt":
|
|
273
|
-
return [];
|
|
274
|
-
case "Apply":
|
|
275
|
-
return expression.args;
|
|
276
|
-
case "Lambda":
|
|
277
|
-
return [expression.body];
|
|
278
|
-
case "And":
|
|
279
|
-
case "Or":
|
|
280
|
-
return expression.operands;
|
|
281
|
-
case "Prime":
|
|
282
|
-
case "Unchanged":
|
|
283
|
-
case "Enabled":
|
|
284
|
-
case "Always":
|
|
285
|
-
case "Eventually":
|
|
286
|
-
return [expression.expression];
|
|
287
|
-
case "If":
|
|
288
|
-
return [expression.condition, expression.consequent, expression.alternative];
|
|
289
|
-
case "Case":
|
|
290
|
-
return [
|
|
291
|
-
...expression.arms.flatMap((arm) => [arm.condition, arm.body]),
|
|
292
|
-
...(expression.other ? [expression.other] : []),
|
|
293
|
-
];
|
|
294
|
-
case "Let":
|
|
295
|
-
return [
|
|
296
|
-
...expression.definitions.flatMap((definition) =>
|
|
297
|
-
definition.kind === "Function"
|
|
298
|
-
? [...definition.bounds.map((bound) => bound.set), definition.body]
|
|
299
|
-
: [definition.body],
|
|
300
|
-
),
|
|
301
|
-
expression.body,
|
|
302
|
-
];
|
|
303
|
-
case "Forall":
|
|
304
|
-
case "Exists":
|
|
305
|
-
return [...expression.bounds.map((bound) => bound.set), expression.body];
|
|
306
|
-
case "UnboundedQuantifier":
|
|
307
|
-
return [expression.body];
|
|
308
|
-
case "Choose":
|
|
309
|
-
return [...(expression.set ? [expression.set] : []), expression.body];
|
|
310
|
-
case "SetEnumeration":
|
|
311
|
-
case "Tuple":
|
|
312
|
-
return expression.elements;
|
|
313
|
-
case "SetFilter":
|
|
314
|
-
return [expression.bound.set, expression.predicate];
|
|
315
|
-
case "SetMap":
|
|
316
|
-
return [expression.expression, ...expression.bounds.map((bound) => bound.set)];
|
|
317
|
-
case "FunctionConstruction":
|
|
318
|
-
return [...expression.bounds.map((bound) => bound.set), expression.body];
|
|
319
|
-
case "FunctionSet":
|
|
320
|
-
return [expression.domain, expression.range];
|
|
321
|
-
case "Record":
|
|
322
|
-
case "RecordSet":
|
|
323
|
-
return expression.fields.map((field) => field.value);
|
|
324
|
-
case "Except":
|
|
325
|
-
return [
|
|
326
|
-
expression.function,
|
|
327
|
-
...expression.updates.flatMap((update) => [
|
|
328
|
-
...update.path.flatMap((step) => (step.kind === "Index" ? step.args : [])),
|
|
329
|
-
update.value,
|
|
330
|
-
]),
|
|
331
|
-
];
|
|
332
|
-
case "FunctionApplication":
|
|
333
|
-
return [expression.function, ...expression.args];
|
|
334
|
-
case "FieldAccess":
|
|
335
|
-
return [expression.record];
|
|
336
|
-
case "Product":
|
|
337
|
-
return expression.factors;
|
|
338
|
-
case "BoxAction":
|
|
339
|
-
case "AngleAction":
|
|
340
|
-
return [expression.action, expression.subscript];
|
|
341
|
-
case "WeakFairness":
|
|
342
|
-
case "StrongFairness":
|
|
343
|
-
return [expression.subscript, expression.action];
|
|
344
|
-
case "Label":
|
|
345
|
-
return [expression.body];
|
|
346
|
-
case "Subexpression":
|
|
347
|
-
return expression.selectors.flatMap((selector) => ("args" in selector ? selector.args : []));
|
|
348
|
-
}
|
|
349
|
-
};
|
|
350
|
-
|
|
351
|
-
export const isLocallyResolved = (expression: Expression) =>
|
|
352
|
-
(expression.kind === "Identifier" || expression.kind === "Apply") &&
|
|
353
|
-
expression.resolution?.kind === "Local";
|
|
354
|
-
|
|
355
267
|
export const getDefinition = (name: string, environment: Environment) =>
|
|
356
268
|
environment.definitions.get(environment.substitutions.get(name) ?? name);
|
|
357
269
|
|
|
@@ -734,7 +646,9 @@ const compileArgumentBinder = (argument: Expression, environment: Environment):
|
|
|
734
646
|
if (global === undefined) {
|
|
735
647
|
return (context) => {
|
|
736
648
|
const binding = lookupScope(context.scope, argument.name);
|
|
737
|
-
return binding?.kind === "Value"
|
|
649
|
+
return binding?.kind === "Value" || binding?.kind === "Thunk"
|
|
650
|
+
? binding
|
|
651
|
+
: createThunk(argument, context);
|
|
738
652
|
};
|
|
739
653
|
}
|
|
740
654
|
}
|
|
@@ -857,11 +771,7 @@ const evaluateLocalIdentifier = (name: string, expression: Expression, context:
|
|
|
857
771
|
const global = findGlobalName(name, context.environment);
|
|
858
772
|
if (global?.kind === "Variable") {
|
|
859
773
|
const value = context.state?.[global.index];
|
|
860
|
-
if (value === undefined)
|
|
861
|
-
throw new TlaEvaluationError(
|
|
862
|
-
`The variable ${name} is not assigned at ${describeLocation(expression)}`,
|
|
863
|
-
);
|
|
864
|
-
}
|
|
774
|
+
if (value === undefined) throw createUnassignedError(name, expression);
|
|
865
775
|
return value;
|
|
866
776
|
}
|
|
867
777
|
if (global?.kind === "Value") return global.value;
|
|
@@ -887,14 +797,29 @@ const IMPURE_BUILTINS = new Set([
|
|
|
887
797
|
export const isImpureBuiltin = (name: string, environment: Environment) =>
|
|
888
798
|
IMPURE_BUILTINS.has(name) || environment.builtins.get(name)?.isStateLevel === true;
|
|
889
799
|
|
|
890
|
-
|
|
800
|
+
interface Impurity {
|
|
801
|
+
builtins: Set<string>;
|
|
802
|
+
definitions: WeakMap<Definition, boolean>;
|
|
803
|
+
}
|
|
804
|
+
|
|
805
|
+
const ANY_EFFECT: Impurity = { builtins: IMPURE_BUILTINS, definitions: new WeakMap() };
|
|
806
|
+
|
|
807
|
+
// An Assert that held holds again, so evaluating it twice looks the same as evaluating it once.
|
|
808
|
+
const REPEATED_EFFECT: Impurity = {
|
|
809
|
+
builtins: new Set([...IMPURE_BUILTINS].filter((name) => name !== "Assert")),
|
|
810
|
+
definitions: new WeakMap(),
|
|
811
|
+
};
|
|
891
812
|
|
|
892
813
|
const isEvaluatedOnce = (definition: Definition, environment: Environment) =>
|
|
893
814
|
definition.kind === "Operator" &&
|
|
894
815
|
definition.params.length === 0 &&
|
|
895
816
|
isConstantLevel(definition, environment);
|
|
896
817
|
|
|
897
|
-
const callsImpureBuiltin = (
|
|
818
|
+
const callsImpureBuiltin = (
|
|
819
|
+
expression: Expression,
|
|
820
|
+
environment: Environment,
|
|
821
|
+
impurity: Impurity,
|
|
822
|
+
): boolean => {
|
|
898
823
|
const name =
|
|
899
824
|
expression.kind === "Identifier"
|
|
900
825
|
? expression.name
|
|
@@ -903,29 +828,35 @@ const callsImpureBuiltin = (expression: Expression, environment: Environment): b
|
|
|
903
828
|
: undefined;
|
|
904
829
|
if (name !== undefined && !isLocallyResolved(expression)) {
|
|
905
830
|
const definition = getDefinition(name, environment);
|
|
906
|
-
|
|
831
|
+
const isImpureCall =
|
|
832
|
+
impurity.builtins.has(name) || environment.builtins.get(name)?.isStateLevel === true;
|
|
833
|
+
if (!definition && isImpureCall) return true;
|
|
907
834
|
if (
|
|
908
835
|
definition &&
|
|
909
836
|
!isEvaluatedOnce(definition, environment) &&
|
|
910
|
-
isImpureDefinition(definition, environment)
|
|
837
|
+
isImpureDefinition(definition, environment, impurity)
|
|
911
838
|
) {
|
|
912
839
|
return true;
|
|
913
840
|
}
|
|
914
841
|
}
|
|
915
|
-
return getChildren(expression).some((child) => callsImpureBuiltin(child, environment));
|
|
842
|
+
return getChildren(expression).some((child) => callsImpureBuiltin(child, environment, impurity));
|
|
916
843
|
};
|
|
917
844
|
|
|
918
845
|
// TLC evaluates a constant definition without parameters once, so only other definitions pass
|
|
919
846
|
// on the side effects and random choices of the builtins they call.
|
|
920
|
-
const isImpureDefinition = (
|
|
921
|
-
|
|
847
|
+
const isImpureDefinition = (
|
|
848
|
+
definition: Definition,
|
|
849
|
+
environment: Environment,
|
|
850
|
+
impurity = ANY_EFFECT,
|
|
851
|
+
): boolean => {
|
|
852
|
+
const cached = impurity.definitions.get(definition);
|
|
922
853
|
if (cached !== undefined) return cached;
|
|
923
|
-
|
|
854
|
+
impurity.definitions.set(definition, false);
|
|
924
855
|
const isImpure =
|
|
925
|
-
callsImpureBuiltin(definition.body, environment) ||
|
|
856
|
+
callsImpureBuiltin(definition.body, environment, impurity) ||
|
|
926
857
|
(definition.kind === "Function" &&
|
|
927
|
-
definition.bounds.some((bound) => callsImpureBuiltin(bound.set, environment)));
|
|
928
|
-
|
|
858
|
+
definition.bounds.some((bound) => callsImpureBuiltin(bound.set, environment, impurity)));
|
|
859
|
+
impurity.definitions.set(definition, isImpure);
|
|
929
860
|
return isImpure;
|
|
930
861
|
};
|
|
931
862
|
|
|
@@ -939,6 +870,12 @@ export const isImpure = (environment: Environment) =>
|
|
|
939
870
|
isImpureDefinition(definition, environment),
|
|
940
871
|
);
|
|
941
872
|
|
|
873
|
+
// Whether evaluating a definition again can show, such as by printing twice.
|
|
874
|
+
export const hasRepeatedEffects = (environment: Environment) =>
|
|
875
|
+
[...environment.definitions.values()].some((definition) =>
|
|
876
|
+
isImpureDefinition(definition, environment, REPEATED_EFFECT),
|
|
877
|
+
);
|
|
878
|
+
|
|
942
879
|
const closedConstants = new WeakMap<Expression, boolean>();
|
|
943
880
|
|
|
944
881
|
export const isClosedConstant = (expression: Expression, environment: Environment): boolean => {
|
|
@@ -1090,7 +1027,7 @@ export const getEvaluator = (expression: Expression, environment: Environment):
|
|
|
1090
1027
|
|
|
1091
1028
|
const entryEvaluators = new WeakMap<Expression, Evaluator>();
|
|
1092
1029
|
|
|
1093
|
-
const getEntryEvaluator = (expression: Expression, environment: Environment) => {
|
|
1030
|
+
export const getEntryEvaluator = (expression: Expression, environment: Environment) => {
|
|
1094
1031
|
const cached = entryEvaluators.get(expression);
|
|
1095
1032
|
if (cached) return cached;
|
|
1096
1033
|
const evaluator =
|
|
@@ -1114,11 +1051,7 @@ const compileIdentifier = (
|
|
|
1114
1051
|
const index = global.index;
|
|
1115
1052
|
return (context) => {
|
|
1116
1053
|
const value = context.state?.[index];
|
|
1117
|
-
if (value === undefined)
|
|
1118
|
-
throw new TlaEvaluationError(
|
|
1119
|
-
`The variable ${name} is not assigned at ${describeLocation(expression)}`,
|
|
1120
|
-
);
|
|
1121
|
-
}
|
|
1054
|
+
if (value === undefined) throw createUnassignedError(name, expression);
|
|
1122
1055
|
return value;
|
|
1123
1056
|
};
|
|
1124
1057
|
}
|
|
@@ -1487,7 +1420,13 @@ const compileFunctionConstruction = (
|
|
|
1487
1420
|
const set = getEvaluator(bound.set, environment);
|
|
1488
1421
|
return (context) => {
|
|
1489
1422
|
const domain = isSingleName ? set(context) : getBoundsDomain(bounds, context);
|
|
1490
|
-
|
|
1423
|
+
// TLC builds the function only when it reduces every domain, and evaluates the body lazily
|
|
1424
|
+
// otherwise.
|
|
1425
|
+
const domains =
|
|
1426
|
+
typeof domain === "object" && domain.kind === "ProductSet" && bounds.length > 1
|
|
1427
|
+
? domain.factors
|
|
1428
|
+
: [domain];
|
|
1429
|
+
if (expression.isRecursive || isKeptLazy || !domains.every(isReducible)) {
|
|
1491
1430
|
const functionValue = createLazyFunction(
|
|
1492
1431
|
domain,
|
|
1493
1432
|
(argument) => body(withScope(context, bindArgument(bounds, context.scope, argument))),
|
|
@@ -1581,10 +1520,7 @@ const compileSetComprehension = (
|
|
|
1581
1520
|
predicate(withScope(context, bindPattern(context.scope, pattern, element))),
|
|
1582
1521
|
"a set filter predicate",
|
|
1583
1522
|
);
|
|
1584
|
-
|
|
1585
|
-
typeof base === "object" &&
|
|
1586
|
-
(base.kind === "Set" || base.kind === "MixedSet" || base.kind === "Interval");
|
|
1587
|
-
if (!isReducible) {
|
|
1523
|
+
if (!isReducible(base)) {
|
|
1588
1524
|
if (isSetValue(base)) return { kind: "FilteredSet", base, test };
|
|
1589
1525
|
throw new TlaEvaluationError(
|
|
1590
1526
|
`TLC encountered a non-enumerable quantifier bound ${formatValue(base)} at ${describeLocation(expression.bound.set)}`,
|
|
@@ -1630,11 +1566,24 @@ const compileSetComprehension = (
|
|
|
1630
1566
|
};
|
|
1631
1567
|
};
|
|
1632
1568
|
|
|
1633
|
-
|
|
1634
|
-
|
|
1635
|
-
|
|
1636
|
-
|
|
1569
|
+
// TLC orders a record's fields by name.
|
|
1570
|
+
export const getSortedFields = (fields: RecordField[]) =>
|
|
1571
|
+
[...fields].sort((left, right) => compareValues(left.name, right.name));
|
|
1572
|
+
|
|
1573
|
+
export const hasDuplicateFields = (sortedFields: RecordField[]) =>
|
|
1574
|
+
sortedFields.some((field, index) => index > 0 && sortedFields[index - 1].name === field.name);
|
|
1575
|
+
|
|
1576
|
+
export const createUnassignedError = (name: string, expression: Expression) =>
|
|
1577
|
+
new TlaEvaluationError(`The variable ${name} is not assigned at ${describeLocation(expression)}`);
|
|
1578
|
+
|
|
1579
|
+
export const createPrimeOutsideActionError = (expression: Expression) =>
|
|
1580
|
+
new TlaEvaluationError(
|
|
1581
|
+
`A primed expression appears outside an action at ${describeLocation(expression)}`,
|
|
1637
1582
|
);
|
|
1583
|
+
|
|
1584
|
+
const compileRecord = (recordFields: RecordField[], environment: Environment): Evaluator => {
|
|
1585
|
+
const fields = getSortedFields(recordFields);
|
|
1586
|
+
const hasDuplicates = hasDuplicateFields(fields);
|
|
1638
1587
|
const values = fields.map((field) => getEvaluator(field.value, environment));
|
|
1639
1588
|
if (hasDuplicates) {
|
|
1640
1589
|
return (context) =>
|
|
@@ -1712,11 +1661,7 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
1712
1661
|
case "Prime": {
|
|
1713
1662
|
const inner = child(expression.expression);
|
|
1714
1663
|
return (context) => {
|
|
1715
|
-
if (!context.next)
|
|
1716
|
-
throw new TlaEvaluationError(
|
|
1717
|
-
`A primed expression appears outside an action at ${describeLocation(expression)}`,
|
|
1718
|
-
);
|
|
1719
|
-
}
|
|
1664
|
+
if (!context.next) throw createPrimeOutsideActionError(expression);
|
|
1720
1665
|
return inner({
|
|
1721
1666
|
environment: context.environment,
|
|
1722
1667
|
scope: context.scope,
|
|
@@ -1755,7 +1700,9 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
1755
1700
|
if (expectBoolean(arm.condition(context), "a CASE guard")) return arm.body(context);
|
|
1756
1701
|
}
|
|
1757
1702
|
if (other) return other(context);
|
|
1758
|
-
throw new TlaEvaluationError(
|
|
1703
|
+
throw new TlaEvaluationError(
|
|
1704
|
+
`Attempted to evaluate a CASE with no conditions true.\n${describeRange(expression)}`,
|
|
1705
|
+
);
|
|
1759
1706
|
};
|
|
1760
1707
|
}
|
|
1761
1708
|
case "Let": {
|
|
@@ -1794,9 +1741,7 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
1794
1741
|
case "Record":
|
|
1795
1742
|
return compileRecord(expression.fields, environment);
|
|
1796
1743
|
case "RecordSet": {
|
|
1797
|
-
const fields =
|
|
1798
|
-
compareValues(left.name, right.name),
|
|
1799
|
-
);
|
|
1744
|
+
const fields = getSortedFields(expression.fields);
|
|
1800
1745
|
const names = fields.map((field) => field.name);
|
|
1801
1746
|
const sets = fields.map((field) => child(field.value));
|
|
1802
1747
|
return (context) => ({ kind: "RecordSet", names, sets: sets.map((set) => set(context)) });
|
package/src/exit-codes.ts
CHANGED
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import type { LivenessChecker } from "./
|
|
1
|
+
import type { LivenessChecker } from "./live-check";
|
|
2
2
|
|
|
3
3
|
// TLC's exit statuses, from EC.ExitStatus.
|
|
4
4
|
export const EXIT_STATUS = {
|
|
@@ -17,12 +17,6 @@ export const EXIT_STATUS = {
|
|
|
17
17
|
} as const;
|
|
18
18
|
|
|
19
19
|
const exitCodes = new WeakMap<Error, number>();
|
|
20
|
-
const moduleExitCodes = new WeakMap<Error, number>();
|
|
21
|
-
const phase = { isNextState: false };
|
|
22
|
-
|
|
23
|
-
export const setNextStatePhase = (isNextState: boolean) => {
|
|
24
|
-
phase.isNextState = isNextState;
|
|
25
|
-
};
|
|
26
20
|
|
|
27
21
|
// The innermost site that knows TLC's exit status for an error sets it first and wins.
|
|
28
22
|
export const setExitCode = <Thrown>(error: Thrown, code: number) => {
|
|
@@ -30,46 +24,30 @@ export const setExitCode = <Thrown>(error: Thrown, code: number) => {
|
|
|
30
24
|
return error;
|
|
31
25
|
};
|
|
32
26
|
|
|
33
|
-
|
|
34
|
-
// escapes the computation of next states. In every other phase, the phase decides the code.
|
|
35
|
-
export const setModuleExitCode = (error: Error, code: number) => {
|
|
36
|
-
if (phase.isNextState) moduleExitCodes.set(error, code);
|
|
37
|
-
};
|
|
38
|
-
|
|
39
|
-
export const getExitCode = (error: Error) => exitCodes.get(error) ?? moduleExitCodes.get(error);
|
|
27
|
+
export const getExitCode = (error: Error) => exitCodes.get(error);
|
|
40
28
|
|
|
41
29
|
// TLC exits with 255 when it fails to process or evaluate a liveness property, in any phase.
|
|
42
|
-
|
|
43
|
-
create: () => LivenessChecker | undefined,
|
|
44
|
-
): LivenessChecker | undefined => {
|
|
30
|
+
const withErrorExitCode = <Result>(run: () => Result) => {
|
|
45
31
|
try {
|
|
46
|
-
|
|
47
|
-
return (
|
|
48
|
-
checker && {
|
|
49
|
-
addInitialState: (index, state) => {
|
|
50
|
-
try {
|
|
51
|
-
checker.addInitialState(index, state);
|
|
52
|
-
} catch (error) {
|
|
53
|
-
throw setExitCode(error, EXIT_STATUS.error);
|
|
54
|
-
}
|
|
55
|
-
},
|
|
56
|
-
addState: (index, state, successors) => {
|
|
57
|
-
try {
|
|
58
|
-
return checker.addState(index, state, successors);
|
|
59
|
-
} catch (error) {
|
|
60
|
-
throw setExitCode(error, EXIT_STATUS.error);
|
|
61
|
-
}
|
|
62
|
-
},
|
|
63
|
-
findViolation: () => {
|
|
64
|
-
try {
|
|
65
|
-
return checker.findViolation();
|
|
66
|
-
} catch (error) {
|
|
67
|
-
throw setExitCode(error, EXIT_STATUS.error);
|
|
68
|
-
}
|
|
69
|
-
},
|
|
70
|
-
}
|
|
71
|
-
);
|
|
32
|
+
return run();
|
|
72
33
|
} catch (error) {
|
|
73
34
|
throw setExitCode(error, EXIT_STATUS.error);
|
|
74
35
|
}
|
|
75
36
|
};
|
|
37
|
+
|
|
38
|
+
export const withLivenessExitCode = (
|
|
39
|
+
create: () => LivenessChecker | undefined,
|
|
40
|
+
): LivenessChecker | undefined => {
|
|
41
|
+
const checker = withErrorExitCode(create);
|
|
42
|
+
return (
|
|
43
|
+
checker && {
|
|
44
|
+
addInitialState: (index, state) =>
|
|
45
|
+
withErrorExitCode(() => checker.addInitialState(index, state)),
|
|
46
|
+
addState: (index, state, successors) =>
|
|
47
|
+
withErrorExitCode(() => checker.addState(index, state, successors)),
|
|
48
|
+
findViolation: () => withErrorExitCode(() => checker.findViolation()),
|
|
49
|
+
getViolatedProperties: (path, cycleStart) =>
|
|
50
|
+
withErrorExitCode(() => checker.getViolatedProperties(path, cycleStart)),
|
|
51
|
+
}
|
|
52
|
+
);
|
|
53
|
+
};
|
package/src/fingerprints.ts
CHANGED
|
@@ -1,12 +1,10 @@
|
|
|
1
1
|
import { getValueFingerprint, getValueHash, type Value } from "./values";
|
|
2
2
|
|
|
3
3
|
const EMPTY = 0;
|
|
4
|
-
const TOMBSTONE = 1;
|
|
5
4
|
const INITIAL_CAPACITY = 1 << 12;
|
|
6
5
|
|
|
7
6
|
interface FingerprintTable {
|
|
8
7
|
insert: (first: number, second: number) => boolean;
|
|
9
|
-
remove: (first: number, second: number) => void;
|
|
10
8
|
}
|
|
11
9
|
|
|
12
10
|
const mix = (hash: number) => {
|
|
@@ -26,15 +24,13 @@ export const writeStateFingerprint = (state: Value[], fingerprint: Int32Array) =
|
|
|
26
24
|
fingerprint[1] = mix(second);
|
|
27
25
|
};
|
|
28
26
|
|
|
29
|
-
export const getFingerprintOwner = (second: number, count: number) => (second >>> 0) % count;
|
|
30
|
-
|
|
31
27
|
export const createFingerprintTable = (): FingerprintTable => {
|
|
32
28
|
const table = { slots: new Int32Array(INITIAL_CAPACITY * 2), used: 0 };
|
|
33
29
|
const findSlot = (slots: Int32Array, first: number, second: number) => {
|
|
34
30
|
const mask = slots.length / 2 - 1;
|
|
35
31
|
for (let index = first & mask; ; index = (index + 1) & mask) {
|
|
36
32
|
const stored = slots[index * 2];
|
|
37
|
-
if (stored === EMPTY
|
|
33
|
+
if (stored === EMPTY) return index;
|
|
38
34
|
if (stored === first && slots[index * 2 + 1] === second) return index;
|
|
39
35
|
}
|
|
40
36
|
};
|
|
@@ -59,11 +55,50 @@ export const createFingerprintTable = (): FingerprintTable => {
|
|
|
59
55
|
table.used++;
|
|
60
56
|
return true;
|
|
61
57
|
},
|
|
62
|
-
remove: (first, second) => {
|
|
63
|
-
const slot = findSlot(table.slots, first, second);
|
|
64
|
-
if (table.slots[slot * 2] !== first) return;
|
|
65
|
-
table.slots[slot * 2] = EMPTY;
|
|
66
|
-
table.slots[slot * 2 + 1] = TOMBSTONE;
|
|
67
|
-
},
|
|
68
58
|
};
|
|
69
59
|
};
|
|
60
|
+
|
|
61
|
+
// Workers share one table of 64-bit fingerprints. The first word is never 0, so 0 marks an empty slot.
|
|
62
|
+
export interface SharedFingerprints {
|
|
63
|
+
slots: BigInt64Array;
|
|
64
|
+
used: Int32Array;
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
const INITIAL_SHARED_CAPACITY = 1 << 10;
|
|
68
|
+
|
|
69
|
+
const insertSharedKey = (slots: BigInt64Array, key: bigint) => {
|
|
70
|
+
const mask = slots.length - 1;
|
|
71
|
+
for (let index = Number(key >> 32n) & mask; ; index = (index + 1) & mask) {
|
|
72
|
+
const stored = Atomics.load(slots, index);
|
|
73
|
+
if (stored === key) return false;
|
|
74
|
+
if (stored !== 0n) continue;
|
|
75
|
+
const previous = Atomics.compareExchange(slots, index, 0n, key);
|
|
76
|
+
if (previous === 0n) return true;
|
|
77
|
+
if (previous === key) return false;
|
|
78
|
+
}
|
|
79
|
+
};
|
|
80
|
+
|
|
81
|
+
export const createSharedFingerprints = (): SharedFingerprints => ({
|
|
82
|
+
slots: new BigInt64Array(new SharedArrayBuffer(INITIAL_SHARED_CAPACITY * 8)),
|
|
83
|
+
used: new Int32Array(new SharedArrayBuffer(4)),
|
|
84
|
+
});
|
|
85
|
+
|
|
86
|
+
export const insertSharedFingerprint = (
|
|
87
|
+
table: SharedFingerprints,
|
|
88
|
+
first: number,
|
|
89
|
+
second: number,
|
|
90
|
+
) => {
|
|
91
|
+
const key = BigInt.asIntN(64, (BigInt(first) << 32n) | BigInt(second >>> 0));
|
|
92
|
+
if (!insertSharedKey(table.slots, key)) return false;
|
|
93
|
+
Atomics.add(table.used, 0, 1);
|
|
94
|
+
return true;
|
|
95
|
+
};
|
|
96
|
+
|
|
97
|
+
export const isSharedFingerprintsFull = (table: SharedFingerprints) =>
|
|
98
|
+
Atomics.load(table.used, 0) * 2 >= table.slots.length;
|
|
99
|
+
|
|
100
|
+
export const growSharedFingerprints = (table: SharedFingerprints): SharedFingerprints => {
|
|
101
|
+
const slots = new BigInt64Array(new SharedArrayBuffer(table.slots.byteLength * 2));
|
|
102
|
+
for (const key of table.slots) if (key !== 0n) insertSharedKey(slots, key);
|
|
103
|
+
return { slots, used: table.used };
|
|
104
|
+
};
|
package/src/instances.ts
CHANGED
|
@@ -1,16 +1,17 @@
|
|
|
1
|
-
import
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
1
|
+
import {
|
|
2
|
+
getChildren,
|
|
3
|
+
isLocallyResolved,
|
|
4
|
+
type Bound,
|
|
5
|
+
type BoundPattern,
|
|
6
|
+
type Definition,
|
|
7
|
+
type Expression,
|
|
8
|
+
type Instance,
|
|
9
|
+
type Module,
|
|
10
|
+
type OperatorParam,
|
|
11
|
+
type SourceLocation,
|
|
12
|
+
type Theorem,
|
|
11
13
|
} from "./ast";
|
|
12
14
|
import { TlaSyntaxError } from "./errors";
|
|
13
|
-
import { getChildren, isLocallyResolved } from "./evaluate";
|
|
14
15
|
import { getArity, getBoundNames, getPatternNames, isBefore } from "./resolve";
|
|
15
16
|
|
|
16
17
|
export const substitutedExpressions = new WeakSet<Expression>();
|
|
@@ -218,7 +219,7 @@ interface Instantiation {
|
|
|
218
219
|
variables: Set<string>;
|
|
219
220
|
getDefinition: (key: string) => Definition | undefined;
|
|
220
221
|
isParameterized: (key: string) => boolean;
|
|
221
|
-
addDefinition: (name: string, create: (key: string) => Definition) => string;
|
|
222
|
+
addDefinition: (source: string, name: string, create: (key: string) => Definition) => string;
|
|
222
223
|
createName: (name: string) => string;
|
|
223
224
|
}
|
|
224
225
|
|
|
@@ -639,7 +640,7 @@ const copyDefinition = (rewrite: Rewrite, key: string): string => {
|
|
|
639
640
|
const instantiation = rewrite.instantiation;
|
|
640
641
|
const definition = instantiation.getDefinition(key);
|
|
641
642
|
if (!definition) return key;
|
|
642
|
-
return instantiation.addDefinition(definition.name, (copyKey) => {
|
|
643
|
+
return instantiation.addDefinition(key, definition.name, (copyKey) => {
|
|
643
644
|
rewrite.copies.set(key, copyKey);
|
|
644
645
|
const rename = createRenamer(rewrite);
|
|
645
646
|
const mapped = renameParams(
|
|
@@ -678,7 +679,7 @@ export const createInstantiation = (instantiation: Instantiation) => {
|
|
|
678
679
|
if (copy !== undefined) return copy;
|
|
679
680
|
const definition = instantiation.getDefinition(key);
|
|
680
681
|
if (!definition) return key;
|
|
681
|
-
return instantiation.addDefinition(definition.name, () =>
|
|
682
|
+
return instantiation.addDefinition(key, definition.name, () =>
|
|
682
683
|
withInstanceParams(definition, instantiation.params, definition.location),
|
|
683
684
|
);
|
|
684
685
|
},
|
package/src/levels.ts
CHANGED
|
@@ -1,13 +1,13 @@
|
|
|
1
|
-
import
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
1
|
+
import {
|
|
2
|
+
getChildren,
|
|
3
|
+
type AssumeProve,
|
|
4
|
+
type Definition,
|
|
5
|
+
type Expression,
|
|
6
|
+
type Module,
|
|
7
|
+
type OperatorParam,
|
|
8
|
+
type SourceLocation,
|
|
8
9
|
} from "./ast";
|
|
9
10
|
import { TlaSyntaxError } from "./errors";
|
|
10
|
-
import { getChildren } from "./evaluate";
|
|
11
11
|
import { mapChildren } from "./instances";
|
|
12
12
|
import { getBoundNames, getPatternNames } from "./resolve";
|
|
13
13
|
import { STANDARD_LEVELS } from "./standard-levels";
|
package/src/lexer.ts
CHANGED
|
@@ -345,6 +345,8 @@ export const tokenize = (source: string): Token[] => {
|
|
|
345
345
|
if (!headerMatch)
|
|
346
346
|
throw new TlaSyntaxError("Expected a module header such as ---- MODULE Name ----");
|
|
347
347
|
const tokens: Token[] = [];
|
|
348
|
+
// Each name is one string object, so looking a name up in a scope compares pointers.
|
|
349
|
+
const names = new Map<string, string>();
|
|
348
350
|
const prefixLines = source.slice(0, headerMatch.index).split("\n");
|
|
349
351
|
const cursor = {
|
|
350
352
|
index: headerMatch.index,
|
|
@@ -380,7 +382,12 @@ export const tokenize = (source: string): Token[] => {
|
|
|
380
382
|
}
|
|
381
383
|
};
|
|
382
384
|
const createError = (message: string) =>
|
|
383
|
-
new TlaSyntaxError(`${message} at line ${cursor.line}, column ${getColumn()}
|
|
385
|
+
new TlaSyntaxError(`${message} at line ${cursor.line}, column ${getColumn()}`, undefined, {
|
|
386
|
+
reason: message,
|
|
387
|
+
line: cursor.line,
|
|
388
|
+
column: getColumn(),
|
|
389
|
+
isEnd: cursor.index >= source.length,
|
|
390
|
+
});
|
|
384
391
|
|
|
385
392
|
while (cursor.index < source.length) {
|
|
386
393
|
const character = source[cursor.index];
|
|
@@ -476,7 +483,9 @@ export const tokenize = (source: string): Token[] => {
|
|
|
476
483
|
pushToken("Keyword", word.slice(0, 3), 3);
|
|
477
484
|
continue;
|
|
478
485
|
}
|
|
479
|
-
|
|
486
|
+
const name = names.get(word) ?? word;
|
|
487
|
+
names.set(name, name);
|
|
488
|
+
pushToken(KEYWORDS.has(word) ? "Keyword" : "Identifier", name, word.length);
|
|
480
489
|
continue;
|
|
481
490
|
}
|
|
482
491
|
const stepLength = matchStep(source, cursor.index);
|