tla-ts 0.0.3-dev.3cf2ad0 → 0.0.3-dev.3ef4193
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 +16 -2
- package/dist/cli.cjs +1 -1
- package/dist/cli.js +1 -1
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +158 -8
- package/dist/index.d.ts +158 -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 -19
- package/dist/run-cli.js +1351 -19
- package/dist/transfer.cjs +88 -18
- package/dist/transfer.js +88 -18
- package/package.json +5 -1
- package/src/ast.ts +146 -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 +1539 -235
- package/src/cli-options.ts +11 -5
- package/src/cli.ts +8 -1
- package/src/codegen.ts +77 -37
- package/src/config.ts +252 -179
- package/src/dependencies.ts +2 -2
- package/src/environment.ts +524 -140
- package/src/errors.ts +224 -3
- package/src/evaluate.ts +796 -246
- package/src/exit-codes.ts +22 -43
- package/src/index.ts +1 -0
- package/src/instances.ts +19 -16
- package/src/java-overrides.ts +104 -25
- package/src/levels.ts +191 -45
- package/src/lexer.ts +37 -5
- package/src/live-check.ts +828 -0
- package/src/liveness.ts +218 -572
- package/src/obligation-expression.ts +2 -2
- package/src/obligation-source.ts +2 -0
- package/src/parallel-worker.ts +13 -4
- package/src/parallel.ts +73 -6
- package/src/parser.ts +436 -144
- 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 +1424 -415
- package/src/run-cli.ts +1200 -143
- package/src/runtime.ts +19 -1
- package/src/sany-builtins.ts +147 -0
- package/src/sany-generator.ts +3112 -0
- package/src/sany-levels.ts +1208 -0
- package/src/sany-lexer.ts +545 -0
- package/src/sany-linter.ts +122 -0
- package/src/sany-modules.ts +1398 -0
- package/src/sany-nodes.ts +463 -0
- package/src/sany-parse-error.ts +2161 -0
- package/src/sany-report.ts +354 -0
- package/src/sany-selectors.ts +738 -0
- package/src/sany-source.ts +248 -0
- package/src/sany-xml.ts +1017 -0
- package/src/spec-description.ts +42 -11
- package/src/standard-modules.ts +200 -148
- package/src/standard-ranges.ts +116 -0
- package/src/state-graph.ts +180 -0
- package/src/subexpressions.ts +231 -171
- package/src/substitution-levels.ts +38 -17
- package/src/successors.ts +219 -107
- package/src/symmetry.ts +189 -53
- package/src/tableau.ts +54 -25
- package/src/tlc-ext.ts +42 -29
- package/src/tlc-messages.ts +329 -0
- package/src/tlc-module.ts +52 -43
- package/src/tlc-order.ts +73 -9
- 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 +708 -180
package/src/values.ts
CHANGED
|
@@ -1,5 +1,6 @@
|
|
|
1
1
|
import { TlaEvaluationError, TlaModuleError } from "./errors";
|
|
2
2
|
import { prettyPrint } from "./pretty-print";
|
|
3
|
+
import type { TlcVersion } from "./tlc-version";
|
|
3
4
|
|
|
4
5
|
export interface ModelValue {
|
|
5
6
|
kind: "ModelValue";
|
|
@@ -29,6 +30,7 @@ export interface FunctionValue {
|
|
|
29
30
|
hash: number;
|
|
30
31
|
fingerprint: number;
|
|
31
32
|
writtenKeys: Value[] | undefined;
|
|
33
|
+
functionClass: FunctionClass | undefined;
|
|
32
34
|
}
|
|
33
35
|
|
|
34
36
|
export interface IntervalValue {
|
|
@@ -76,10 +78,17 @@ export interface SetOperationValue {
|
|
|
76
78
|
right: Value;
|
|
77
79
|
}
|
|
78
80
|
|
|
81
|
+
// TLC prints a set filter as its bound names and the location of its predicate.
|
|
82
|
+
interface FilteredSetSource {
|
|
83
|
+
names: string;
|
|
84
|
+
predicate: string;
|
|
85
|
+
}
|
|
86
|
+
|
|
79
87
|
export interface FilteredSetValue {
|
|
80
88
|
kind: "FilteredSet";
|
|
81
89
|
base: Value;
|
|
82
90
|
test: (element: Value) => boolean;
|
|
91
|
+
source?: FilteredSetSource;
|
|
83
92
|
}
|
|
84
93
|
|
|
85
94
|
// UNION S when some element of S isn't a set enumeration. TLC enumerates it only when it has to.
|
|
@@ -103,6 +112,7 @@ export interface LazyFunctionValue {
|
|
|
103
112
|
domain: Value;
|
|
104
113
|
apply: (argument: Value) => Value;
|
|
105
114
|
source?: LazyFunctionSource;
|
|
115
|
+
functionClass?: FunctionClass;
|
|
106
116
|
}
|
|
107
117
|
|
|
108
118
|
export type Value =
|
|
@@ -137,6 +147,12 @@ export const isSetValue = (value: Value) =>
|
|
|
137
147
|
value.kind !== "Function" &&
|
|
138
148
|
value.kind !== "LazyFunction";
|
|
139
149
|
|
|
150
|
+
// TLC's Reducible values, SetEnumValue and IntervalValue, which combine with another set element by
|
|
151
|
+
// element.
|
|
152
|
+
export const isReducibleSet = (value: Value): value is SetValue | MixedSetValue | IntervalValue =>
|
|
153
|
+
typeof value === "object" &&
|
|
154
|
+
(value.kind === "Set" || value.kind === "MixedSet" || value.kind === "Interval");
|
|
155
|
+
|
|
140
156
|
export const isFunctionValue = (value: Value): value is FunctionValue | LazyFunctionValue =>
|
|
141
157
|
typeof value === "object" && (value.kind === "Function" || value.kind === "LazyFunction");
|
|
142
158
|
|
|
@@ -175,7 +191,7 @@ export const getWrittenPairs = (functionValue: FunctionValue): [Value, Value][]
|
|
|
175
191
|
};
|
|
176
192
|
|
|
177
193
|
export const createWrittenRecord = (names: Value[], range: Value[], writtenNames: Value[]) =>
|
|
178
|
-
setWrittenOrder(
|
|
194
|
+
setWrittenOrder(createSortedRecord(names, range), writtenNames);
|
|
179
195
|
|
|
180
196
|
// TLC sorts a value it compares even with itself, and every value inside it, so a value it has
|
|
181
197
|
// hashed or fingerprinted is already sorted.
|
|
@@ -260,7 +276,10 @@ const checkModelValueTypes = (left: Value, right: Value, isEquality: boolean) =>
|
|
|
260
276
|
|
|
261
277
|
// TLC orders strings and model value names by when it first interned the text, so every
|
|
262
278
|
// check sets the order of its spec's strings before it builds any value.
|
|
263
|
-
const stringOrder
|
|
279
|
+
const stringOrder: { ranks: Record<string, number>; size: number } = {
|
|
280
|
+
ranks: Object.create(null),
|
|
281
|
+
size: 0,
|
|
282
|
+
};
|
|
264
283
|
|
|
265
284
|
export const setStringOrder = (texts: Iterable<string>) => {
|
|
266
285
|
stringOrder.ranks = Object.create(null);
|
|
@@ -269,6 +288,14 @@ export const setStringOrder = (texts: Iterable<string>) => {
|
|
|
269
288
|
for (const text of texts) rankString(text);
|
|
270
289
|
};
|
|
271
290
|
|
|
291
|
+
// TLC 1.7.4 prints an empty function that isn't a tuple with a space between its brackets, and
|
|
292
|
+
// looks a key up in a function differently, so every check also sets the version its values follow.
|
|
293
|
+
const valueVersion = { is174: false };
|
|
294
|
+
|
|
295
|
+
export const setValueVersion = (version: TlcVersion | undefined) => {
|
|
296
|
+
valueVersion.is174 = version === "1.7.4";
|
|
297
|
+
};
|
|
298
|
+
|
|
272
299
|
export const rankString = (text: string) => {
|
|
273
300
|
if (stringOrder.ranks[text] === undefined) stringOrder.ranks[text] = stringOrder.size++;
|
|
274
301
|
return text;
|
|
@@ -415,9 +442,85 @@ export const createSortedFunction = (domain: Value[], range: Value[]): FunctionV
|
|
|
415
442
|
hash: 0,
|
|
416
443
|
fingerprint: 0,
|
|
417
444
|
writtenKeys: undefined,
|
|
445
|
+
functionClass: undefined,
|
|
418
446
|
});
|
|
419
447
|
|
|
448
|
+
// TLC words a failed function application by the Java class of the function: FcnLambdaValue for
|
|
449
|
+
// [x \in S |-> e], TupleValue for <<...>> and what the sequence operators build, RecordValue for
|
|
450
|
+
// [a |-> e], and FcnRcdValue for any other function.
|
|
451
|
+
export type FunctionClass = "lambda" | "tuple" | "record";
|
|
452
|
+
|
|
453
|
+
// Whether a lambda exists for markFingerprinted to find, so that a spec without one skips the walk.
|
|
454
|
+
const lambdaPresence = { isPresent: false };
|
|
455
|
+
|
|
456
|
+
export const setFunctionClass = <FunctionLike extends FunctionValue | LazyFunctionValue>(
|
|
457
|
+
functionValue: FunctionLike,
|
|
458
|
+
functionClass: FunctionClass | undefined,
|
|
459
|
+
) => {
|
|
460
|
+
if (functionClass === "lambda") lambdaPresence.isPresent = true;
|
|
461
|
+
if (functionClass !== undefined) functionValue.functionClass = functionClass;
|
|
462
|
+
return functionValue;
|
|
463
|
+
};
|
|
464
|
+
|
|
465
|
+
export const getFunctionClass = (value: Value) =>
|
|
466
|
+
typeof value === "object" && (value.kind === "Function" || value.kind === "LazyFunction")
|
|
467
|
+
? value.functionClass
|
|
468
|
+
: undefined;
|
|
469
|
+
|
|
470
|
+
export const markLambdaFunction = <FunctionLike extends FunctionValue | LazyFunctionValue>(
|
|
471
|
+
functionValue: FunctionLike,
|
|
472
|
+
) => setFunctionClass(functionValue, "lambda");
|
|
473
|
+
|
|
474
|
+
const fingerprintedValues = new WeakSet<ObjectValue>();
|
|
475
|
+
|
|
476
|
+
// The lazy sets TLC has cached the elements of. TLC caches a set as the receiver of compareTo,
|
|
477
|
+
// equals, size, and fingerPrint, not as their argument, and enumerates the sets an uncached one
|
|
478
|
+
// combines, duplicates and all.
|
|
479
|
+
const cachedSets = new WeakSet<ObjectValue>();
|
|
480
|
+
|
|
481
|
+
// Whether the spec has built a UNION or \cup set, the sets that stream duplicates, so that a spec
|
|
482
|
+
// without one skips tracking what TLC caches.
|
|
483
|
+
const streamedSetPresence = { isPresent: false };
|
|
484
|
+
|
|
485
|
+
export const markStreamedSet = <Streamed extends UnionValue | SetOperationValue>(
|
|
486
|
+
value: Streamed,
|
|
487
|
+
) => {
|
|
488
|
+
streamedSetPresence.isPresent = true;
|
|
489
|
+
return value;
|
|
490
|
+
};
|
|
491
|
+
|
|
492
|
+
const cacheSet = (value: Value) => {
|
|
493
|
+
if (streamedSetPresence.isPresent && typeof value === "object") cachedSets.add(value);
|
|
494
|
+
};
|
|
495
|
+
|
|
496
|
+
// FcnLambdaValue#fingerPrint caches the FcnRcdValue the function enumerates to, which applies it
|
|
497
|
+
// from then on, so a function TLC has fingerprinted is no longer a lambda.
|
|
498
|
+
export const markFingerprinted = (value: Value): void => {
|
|
499
|
+
if (
|
|
500
|
+
(!lambdaPresence.isPresent && !streamedSetPresence.isPresent) ||
|
|
501
|
+
typeof value !== "object" ||
|
|
502
|
+
fingerprintedValues.has(value)
|
|
503
|
+
) {
|
|
504
|
+
return;
|
|
505
|
+
}
|
|
506
|
+
fingerprintedValues.add(value);
|
|
507
|
+
if (value.kind === "Function") {
|
|
508
|
+
if (value.functionClass === "lambda") value.functionClass = undefined;
|
|
509
|
+
value.domain.forEach(markFingerprinted);
|
|
510
|
+
value.range.forEach(markFingerprinted);
|
|
511
|
+
} else if (value.kind === "Set" || value.kind === "MixedSet") {
|
|
512
|
+
value.elements.forEach(markFingerprinted);
|
|
513
|
+
} else if (isSetValue(value) && isEnumerable(value)) {
|
|
514
|
+
cacheSet(value);
|
|
515
|
+
toFiniteSet(value).elements.forEach(markFingerprinted);
|
|
516
|
+
}
|
|
517
|
+
};
|
|
518
|
+
|
|
519
|
+
export const createSortedRecord = (names: Value[], range: Value[]) =>
|
|
520
|
+
setFunctionClass(createSortedFunction(names, range), "record");
|
|
521
|
+
|
|
420
522
|
export const valuesEqual = (left: Value, right: Value): boolean => {
|
|
523
|
+
cacheSet(left);
|
|
421
524
|
if (left === right) {
|
|
422
525
|
if (writtenOrderUse.isUsed) forgetWrittenOrder(left);
|
|
423
526
|
return left !== ANY_SET || compareAny(left);
|
|
@@ -491,28 +594,36 @@ export const valuesEqual = (left: Value, right: Value): boolean => {
|
|
|
491
594
|
return compareValues(left, right) === 0;
|
|
492
595
|
};
|
|
493
596
|
|
|
494
|
-
|
|
495
|
-
|
|
496
|
-
|
|
497
|
-
|
|
498
|
-
|
|
499
|
-
|
|
500
|
-
|
|
501
|
-
|
|
502
|
-
|
|
503
|
-
|
|
504
|
-
(
|
|
505
|
-
|
|
506
|
-
|
|
507
|
-
|
|
508
|
-
|
|
509
|
-
(
|
|
510
|
-
|
|
511
|
-
|
|
512
|
-
|
|
513
|
-
|
|
597
|
+
// TLC prints and words errors about an equal function by its Java class, so a value can stand for
|
|
598
|
+
// another in a state only if each function in it has the same class.
|
|
599
|
+
const createSameValueCheck = (isClassSensitive: boolean) => {
|
|
600
|
+
const areSameValues = (left: Value[], right: Value[]) =>
|
|
601
|
+
left === right ||
|
|
602
|
+
(left.length === right.length && left.every((element, index) => isSame(element, right[index])));
|
|
603
|
+
const isSame = (left: Value, right: Value): boolean => {
|
|
604
|
+
if (left === right) return true;
|
|
605
|
+
if (typeof left !== "object" || typeof right !== "object") return false;
|
|
606
|
+
if (left.kind === "Set" && right.kind === "Set")
|
|
607
|
+
return (
|
|
608
|
+
(left.hash === 0 || right.hash === 0 || left.hash === right.hash) &&
|
|
609
|
+
areSameValues(left.elements, right.elements)
|
|
610
|
+
);
|
|
611
|
+
if (left.kind === "Function" && right.kind === "Function")
|
|
612
|
+
return (
|
|
613
|
+
(!isClassSensitive || left.functionClass === right.functionClass) &&
|
|
614
|
+
(left.hash === 0 || right.hash === 0 || left.hash === right.hash) &&
|
|
615
|
+
areSameValues(left.domain, right.domain) &&
|
|
616
|
+
areSameValues(left.range, right.range)
|
|
617
|
+
);
|
|
618
|
+
return getValueKey(left) === getValueKey(right);
|
|
619
|
+
};
|
|
620
|
+
return isSame;
|
|
514
621
|
};
|
|
515
622
|
|
|
623
|
+
export const isSameValue = createSameValueCheck(false);
|
|
624
|
+
|
|
625
|
+
export const isInterchangeableValue = createSameValueCheck(true);
|
|
626
|
+
|
|
516
627
|
// The comparisons above fail with their own messages. These follow the compareTo and equals
|
|
517
628
|
// methods of TLC's Java value classes, which word a failure by the class of the left operand, so a
|
|
518
629
|
// failed comparison runs again through them to fail as TLC does.
|
|
@@ -668,7 +779,7 @@ const compareFunctionLikeTlc = (left: FunctionValue | LazyFunctionValue, right:
|
|
|
668
779
|
compareElementsLikeTlc(functionValue.range, tuple)
|
|
669
780
|
);
|
|
670
781
|
}
|
|
671
|
-
if (left
|
|
782
|
+
if (getFunctionClass(left) === "record") {
|
|
672
783
|
const record = toTlcRecord(right);
|
|
673
784
|
if (!record) {
|
|
674
785
|
if (isModelValue(right)) return compareModelValueWith(right, left);
|
|
@@ -786,7 +897,7 @@ const equalsFunctionLikeTlc = (left: FunctionValue | LazyFunctionValue, right: V
|
|
|
786
897
|
equalsElementsLikeTlc(functionValue.range, tuple)
|
|
787
898
|
);
|
|
788
899
|
}
|
|
789
|
-
if (left
|
|
900
|
+
if (getFunctionClass(left) === "record") {
|
|
790
901
|
const record = toTlcRecord(right);
|
|
791
902
|
if (!record) {
|
|
792
903
|
if (isModelValue(right)) return equalsModelValueWith(right, left);
|
|
@@ -838,32 +949,65 @@ const equalsLikeTlc = (left: Value, right: Value): boolean => {
|
|
|
838
949
|
const sortLikeTlc = (elements: Value[]) => {
|
|
839
950
|
const sorted: Value[] = [];
|
|
840
951
|
for (const element of elements) {
|
|
841
|
-
const
|
|
842
|
-
|
|
843
|
-
const middle = bounds.low + ((bounds.high - bounds.low) >> 1);
|
|
844
|
-
bounds.comparison = compareLikeTlc(element, sorted[middle]);
|
|
845
|
-
if (bounds.comparison === 0) break;
|
|
846
|
-
if (bounds.comparison < 0) bounds.high = middle;
|
|
847
|
-
else bounds.low = middle + 1;
|
|
848
|
-
}
|
|
849
|
-
if (bounds.comparison !== 0) sorted.splice(bounds.low, 0, element);
|
|
952
|
+
const found = searchLikeTlc(element, sorted);
|
|
953
|
+
if (!found.isFound) sorted.splice(found.index, 0, element);
|
|
850
954
|
}
|
|
851
955
|
return sorted;
|
|
852
956
|
};
|
|
853
957
|
|
|
854
|
-
//
|
|
958
|
+
// Calls a method of a value as TLC does, whose failure the value heads when it has a source.
|
|
959
|
+
const callTracedMethod = <Result>(receiver: Value, method: () => Result) => {
|
|
960
|
+
const sets = setTrace.sets;
|
|
961
|
+
if (sets === undefined) return method();
|
|
962
|
+
sets.push(receiver);
|
|
963
|
+
const result = method();
|
|
964
|
+
sets.pop();
|
|
965
|
+
return result;
|
|
966
|
+
};
|
|
967
|
+
|
|
968
|
+
// ValueVec.search on sorted elements: a binary search with compareTo, which ends where the element
|
|
969
|
+
// is or would go.
|
|
970
|
+
const searchLikeTlc = (element: Value, sorted: Value[]) => {
|
|
971
|
+
const bounds = { low: 0, high: sorted.length };
|
|
972
|
+
while (bounds.low < bounds.high) {
|
|
973
|
+
const middle = bounds.low + ((bounds.high - bounds.low) >> 1);
|
|
974
|
+
const comparison = callTracedMethod(element, () => compareLikeTlc(element, sorted[middle]));
|
|
975
|
+
if (comparison === 0) return { index: middle, isFound: true };
|
|
976
|
+
if (comparison < 0) bounds.high = middle;
|
|
977
|
+
else bounds.low = middle + 1;
|
|
978
|
+
}
|
|
979
|
+
return { index: bounds.low, isFound: false };
|
|
980
|
+
};
|
|
981
|
+
|
|
982
|
+
// TLC checks membership in a set enumeration it hasn't sorted element by element, with the equals
|
|
983
|
+
// method of each member.
|
|
855
984
|
const isElementOfLikeTlc = (element: Value, elements: Value[]) =>
|
|
856
|
-
elements.some((member) => equalsLikeTlc(member, element));
|
|
985
|
+
elements.some((member) => callTracedMethod(member, () => equalsLikeTlc(member, element)));
|
|
857
986
|
|
|
858
|
-
|
|
859
|
-
|
|
860
|
-
|
|
861
|
-
|
|
862
|
-
|
|
863
|
-
|
|
987
|
+
// The sets TLC has normalized, whose membership ValueVec.search checks by binary search with
|
|
988
|
+
// compareTo instead of element by element.
|
|
989
|
+
const normalizedSets = new WeakSet<SetValue>();
|
|
990
|
+
|
|
991
|
+
// IValue.deepNormalize, which TLC applies to the constants of the config and the constant
|
|
992
|
+
// definitions it computes as it starts.
|
|
993
|
+
export const markNormalized = (value: Value): void => {
|
|
994
|
+
if (typeof value !== "object") return;
|
|
995
|
+
if (value.kind === "Set") {
|
|
996
|
+
normalizedSets.add(value);
|
|
997
|
+
value.elements.forEach(markNormalized);
|
|
998
|
+
}
|
|
999
|
+
if (value.kind === "Function") {
|
|
1000
|
+
value.domain.forEach(markNormalized);
|
|
1001
|
+
value.range.forEach(markNormalized);
|
|
864
1002
|
}
|
|
865
1003
|
};
|
|
866
1004
|
|
|
1005
|
+
export const isEqualLikeTlc = (left: Value, right: Value) =>
|
|
1006
|
+
computeLikeTlcOnFailure(
|
|
1007
|
+
() => valuesEqual(left, right),
|
|
1008
|
+
() => equalsLikeTlc(left, right),
|
|
1009
|
+
);
|
|
1010
|
+
|
|
867
1011
|
const isStrictlySorted = (elements: Value[]) => {
|
|
868
1012
|
for (let index = 1; index < elements.length; index++) {
|
|
869
1013
|
if (compareValues(elements[index - 1], elements[index]) >= 0) return false;
|
|
@@ -872,6 +1016,8 @@ const isStrictlySorted = (elements: Value[]) => {
|
|
|
872
1016
|
};
|
|
873
1017
|
|
|
874
1018
|
export const createSet = (elements: Value[]): SetValue => {
|
|
1019
|
+
// ValueVec.sort compares each element after the first with those before it.
|
|
1020
|
+
for (let index = 1; index < elements.length; index++) cacheSet(elements[index]);
|
|
875
1021
|
if (elements.length < 2 || isStrictlySorted(elements)) return createSortedSet(elements);
|
|
876
1022
|
const sorted = [...elements].sort(compareValues);
|
|
877
1023
|
const unique = [sorted[0]];
|
|
@@ -883,14 +1029,11 @@ export const createSet = (elements: Value[]): SetValue => {
|
|
|
883
1029
|
|
|
884
1030
|
// TLC builds a set enumeration without sorting it, so one whose elements it can't compare still
|
|
885
1031
|
// evaluates.
|
|
886
|
-
export const createEnumeratedSet = (elements: Value[]): SetValue | MixedSetValue =>
|
|
887
|
-
|
|
888
|
-
|
|
889
|
-
|
|
890
|
-
|
|
891
|
-
return { kind: "MixedSet", elements };
|
|
892
|
-
}
|
|
893
|
-
};
|
|
1032
|
+
export const createEnumeratedSet = (elements: Value[]): SetValue | MixedSetValue =>
|
|
1033
|
+
computeLikeTlcOnFailure<SetValue | MixedSetValue>(
|
|
1034
|
+
() => createSet(elements),
|
|
1035
|
+
() => ({ kind: "MixedSet", elements }),
|
|
1036
|
+
);
|
|
894
1037
|
|
|
895
1038
|
export const EMPTY_SET = createSortedSet([]);
|
|
896
1039
|
|
|
@@ -969,12 +1112,15 @@ export const unionSorted = (left: SetValue, right: SetValue): SetValue => {
|
|
|
969
1112
|
}
|
|
970
1113
|
if (added.length === 0) return left;
|
|
971
1114
|
const union = createSortedSet(merged);
|
|
972
|
-
if (left.hash !== 0) {
|
|
1115
|
+
if (left.hash !== 0 && left.hash !== UNFINGERPRINTABLE_HASH) {
|
|
973
1116
|
let hash = left.hash;
|
|
974
|
-
|
|
975
|
-
|
|
1117
|
+
let index = 0;
|
|
1118
|
+
for (; index < added.length; index++) {
|
|
1119
|
+
const elementHash = getValueHash(added[index]);
|
|
1120
|
+
if (elementHash === UNFINGERPRINTABLE_HASH) break;
|
|
1121
|
+
hash = (hash + getElementContribution(elementHash)) | 0;
|
|
976
1122
|
}
|
|
977
|
-
union.hash = hash;
|
|
1123
|
+
if (index === added.length) union.hash = hash;
|
|
978
1124
|
}
|
|
979
1125
|
if (left.fingerprint !== 0) {
|
|
980
1126
|
let fingerprint = left.fingerprint;
|
|
@@ -1059,23 +1205,27 @@ const getIntervalValue = (high: number): IntervalValue => {
|
|
|
1059
1205
|
};
|
|
1060
1206
|
|
|
1061
1207
|
export const createTuple = (elements: Value[]): FunctionValue =>
|
|
1062
|
-
createSortedFunction(getIntervalDomain(elements.length), elements);
|
|
1208
|
+
setFunctionClass(createSortedFunction(getIntervalDomain(elements.length), elements), "tuple");
|
|
1063
1209
|
|
|
1064
|
-
export const createRecord = (fields: [string, Value][]): FunctionValue =>
|
|
1210
|
+
export const createRecord = (fields: [string, Value][]): FunctionValue =>
|
|
1211
|
+
setFunctionClass(createFunction(fields), "record");
|
|
1065
1212
|
|
|
1066
1213
|
// TLC's Enumerable classes: every set except the ones it implements in Java.
|
|
1067
|
-
const isTlcEnumerable = (value: Value) => isSetValue(value) && !isOverriddenSet(value);
|
|
1214
|
+
export const isTlcEnumerable = (value: Value) => isSetValue(value) && !isOverriddenSet(value);
|
|
1068
1215
|
|
|
1069
1216
|
const formatUnion = (value: UnionValue, isStrict = false) =>
|
|
1070
1217
|
`UNION(${formatValue(value.base, isStrict)})`;
|
|
1071
1218
|
|
|
1072
|
-
const getUnionSets = (
|
|
1219
|
+
const getUnionSets = (
|
|
1220
|
+
value: UnionValue,
|
|
1221
|
+
getElements = (set: Value) => toFiniteSet(set).elements,
|
|
1222
|
+
) => {
|
|
1073
1223
|
if (!isTlcEnumerable(value.base)) {
|
|
1074
1224
|
throw new TlaEvaluationError(
|
|
1075
1225
|
`Attempted to enumerate the nonenumerable set:\n${formatUnion(value)}`,
|
|
1076
1226
|
);
|
|
1077
1227
|
}
|
|
1078
|
-
return
|
|
1228
|
+
return getElements(value.base);
|
|
1079
1229
|
};
|
|
1080
1230
|
|
|
1081
1231
|
const getUnionSet = (set: Value, index: number, union: UnionValue) => {
|
|
@@ -1111,7 +1261,7 @@ export const isEnumerable = (value: Value): boolean => {
|
|
|
1111
1261
|
case "ProductSet":
|
|
1112
1262
|
return value.factors.every(isEnumerable) || getEmptiness(value) === true;
|
|
1113
1263
|
case "Union":
|
|
1114
|
-
return isEnumerable(value.base) &&
|
|
1264
|
+
return isEnumerable(value.base) && getStreamedElements(value.base).every(isEnumerable);
|
|
1115
1265
|
case "SetOperation":
|
|
1116
1266
|
if (value.operator === "\\cup") return isEnumerable(value.left) && isEnumerable(value.right);
|
|
1117
1267
|
if (value.operator === "\\cap") return isEnumerable(value.left) || isEnumerable(value.right);
|
|
@@ -1184,6 +1334,41 @@ const advanceCombination = (indices: number[], length: number) => {
|
|
|
1184
1334
|
return false;
|
|
1185
1335
|
};
|
|
1186
1336
|
|
|
1337
|
+
// TLC enumerates SUBSET S lazily, by size and then in the order of S, so a quantifier that finds
|
|
1338
|
+
// its witness early never builds the rest. For a power set too large to build, the elements are
|
|
1339
|
+
// computed in that order as a loop reads them.
|
|
1340
|
+
export const getLazySubsets = (value: Value): Value[] | undefined => {
|
|
1341
|
+
if (typeof value !== "object" || value.kind !== "Subset" || isOverriddenSet(value.base)) {
|
|
1342
|
+
return undefined;
|
|
1343
|
+
}
|
|
1344
|
+
const base = toFiniteSet(value.base).elements;
|
|
1345
|
+
if (base.length <= MAXIMUM_ENUMERATED_SUBSET_BASE) return undefined;
|
|
1346
|
+
const cursor = { index: -1, indices: [0] };
|
|
1347
|
+
const getSubset = (index: number) => {
|
|
1348
|
+
if (index <= cursor.index) cursor.index = -1;
|
|
1349
|
+
while (cursor.index < index) {
|
|
1350
|
+
if (cursor.index === -1) cursor.indices = [];
|
|
1351
|
+
else if (!advanceCombination(cursor.indices, base.length)) {
|
|
1352
|
+
cursor.indices = Array.from({ length: cursor.indices.length + 1 }, (_, item) => item);
|
|
1353
|
+
}
|
|
1354
|
+
cursor.index++;
|
|
1355
|
+
}
|
|
1356
|
+
return createSortedSet(cursor.indices.map((item) => base[item]));
|
|
1357
|
+
};
|
|
1358
|
+
const length = 2 ** base.length;
|
|
1359
|
+
const isIndex = (property: string | symbol) =>
|
|
1360
|
+
typeof property === "string" && /^\d+$/.test(property) && Number(property) < length;
|
|
1361
|
+
return new Proxy<Value[]>([], {
|
|
1362
|
+
get: (target, property, receiver) => {
|
|
1363
|
+
if (property === "length") return length;
|
|
1364
|
+
return isIndex(property)
|
|
1365
|
+
? getSubset(Number(property))
|
|
1366
|
+
: Reflect.get(target, property, receiver);
|
|
1367
|
+
},
|
|
1368
|
+
has: (target, property) => isIndex(property) || Reflect.has(target, property),
|
|
1369
|
+
});
|
|
1370
|
+
};
|
|
1371
|
+
|
|
1187
1372
|
const getSortedSubsets = (base: Value[]) => {
|
|
1188
1373
|
const subsets: Value[] = [];
|
|
1189
1374
|
for (let size = 0; size <= base.length; size++) {
|
|
@@ -1195,7 +1380,30 @@ const getSortedSubsets = (base: Value[]) => {
|
|
|
1195
1380
|
return subsets;
|
|
1196
1381
|
};
|
|
1197
1382
|
|
|
1198
|
-
|
|
1383
|
+
// The Enumerator of a set of records or tuples enumerates its sets in turn and stops at the first
|
|
1384
|
+
// empty one, which leaves the product empty. Later versions of TLC decide that the set is empty
|
|
1385
|
+
// before they enumerate it.
|
|
1386
|
+
const getComponentElements = (
|
|
1387
|
+
sets: Value[],
|
|
1388
|
+
getElements: (set: Value) => Value[],
|
|
1389
|
+
describeUnenumerable: (set: Value, index: number) => string,
|
|
1390
|
+
) => {
|
|
1391
|
+
const lists: Value[][] = [];
|
|
1392
|
+
for (let index = 0; index < sets.length; index++) {
|
|
1393
|
+
const set = sets[index];
|
|
1394
|
+
if (isOverriddenSet(set)) throw new TlaEvaluationError(describeUnenumerable(set, index));
|
|
1395
|
+
const elements = getElements(set);
|
|
1396
|
+
if (elements.length === 0) return [[]];
|
|
1397
|
+
lists.push(elements);
|
|
1398
|
+
}
|
|
1399
|
+
return lists;
|
|
1400
|
+
};
|
|
1401
|
+
|
|
1402
|
+
// getElements enumerates the sets a set of functions, records, or tuples combines.
|
|
1403
|
+
const enumerateSet = (
|
|
1404
|
+
value: Value,
|
|
1405
|
+
getElements = (set: Value) => toFiniteSet(set).elements,
|
|
1406
|
+
): Value[] => {
|
|
1199
1407
|
if (typeof value !== "object")
|
|
1200
1408
|
throw new TlaEvaluationError(`Expected a set but found ${formatValue(value)}`);
|
|
1201
1409
|
switch (value.kind) {
|
|
@@ -1209,61 +1417,63 @@ const enumerateSet = (value: Value): Value[] => {
|
|
|
1209
1417
|
return elements;
|
|
1210
1418
|
}
|
|
1211
1419
|
case "Subset": {
|
|
1212
|
-
|
|
1213
|
-
|
|
1214
|
-
if (base
|
|
1420
|
+
// SubsetValue.toSetEnum sizes the set before it enumerates it, and enumerates only the empty
|
|
1421
|
+
// set of a value of size 0, a function with an empty domain among them.
|
|
1422
|
+
if (getCardinality(value.base) === 0) return getSortedSubsets([]);
|
|
1423
|
+
if (!isSetValue(value.base)) {
|
|
1215
1424
|
throw new TlaEvaluationError(
|
|
1216
|
-
`
|
|
1425
|
+
`Attempted to compute the value of an expression of form\nSUBSET S, but S is a non-enumerable value:\n${prettyPrint(formatValue(value.base))}`,
|
|
1217
1426
|
);
|
|
1218
1427
|
}
|
|
1428
|
+
const base = toFiniteSet(value.base).elements;
|
|
1429
|
+
if (base.length > MAXIMUM_ENUMERATED_SUBSET_BASE) {
|
|
1430
|
+
throw new TlaEvaluationError(describeOverflow(value));
|
|
1431
|
+
}
|
|
1219
1432
|
return getSortedSubsets(base);
|
|
1220
1433
|
}
|
|
1221
1434
|
case "FunctionSet": {
|
|
1222
|
-
if (isEmptySet(value)) return [];
|
|
1435
|
+
if (!valueVersion.is174 && isEmptySet(value)) return [];
|
|
1223
1436
|
if (isOverriddenSet(value.domain)) {
|
|
1224
1437
|
throw new TlaEvaluationError(
|
|
1225
1438
|
`Attempted to enumerate a set of the form [D -> R],but the domain D:\n${formatValue(value.domain)}\ncannot be enumerated.`,
|
|
1226
1439
|
);
|
|
1227
1440
|
}
|
|
1228
1441
|
const domain = getFunctionDomain(value.domain);
|
|
1229
|
-
|
|
1442
|
+
// TLC 1.7.4 requires an enumerable range even of an empty domain.
|
|
1443
|
+
if ((domain.length > 0 || valueVersion.is174) && isOverriddenSet(value.range)) {
|
|
1230
1444
|
throw new TlaEvaluationError(
|
|
1231
1445
|
`Attempted to enumerate a set of the form [D -> R],but the range R:\n${formatValue(value.range)}\ncannot be enumerated.`,
|
|
1232
1446
|
);
|
|
1233
1447
|
}
|
|
1234
|
-
const range = domain.length === 0 ? [] :
|
|
1448
|
+
const range = domain.length === 0 ? [] : getElements(value.range);
|
|
1235
1449
|
return getCartesianProduct(domain.map(() => range)).map((combination): Value =>
|
|
1236
1450
|
createSortedFunction(domain, combination),
|
|
1237
1451
|
);
|
|
1238
1452
|
}
|
|
1239
1453
|
case "RecordSet": {
|
|
1240
|
-
if (isEmptySet(value)) return [];
|
|
1241
|
-
const fields =
|
|
1242
|
-
|
|
1243
|
-
|
|
1244
|
-
|
|
1245
|
-
)
|
|
1246
|
-
|
|
1247
|
-
return toFiniteSet(set).elements;
|
|
1248
|
-
});
|
|
1454
|
+
if (!valueVersion.is174 && isEmptySet(value)) return [];
|
|
1455
|
+
const fields = getComponentElements(
|
|
1456
|
+
value.sets,
|
|
1457
|
+
getElements,
|
|
1458
|
+
(set, index) =>
|
|
1459
|
+
`Attempted to enumerate a set of the form [l1 : v1, ..., ln : vn],\nbut can't enumerate the value of the \`${value.names[index]}' field:\n${formatValue(set)}`,
|
|
1460
|
+
);
|
|
1249
1461
|
return getCartesianProduct(fields).map((combination) =>
|
|
1250
1462
|
createRecord(value.names.map((name, index): [string, Value] => [name, combination[index]])),
|
|
1251
1463
|
);
|
|
1252
1464
|
}
|
|
1253
1465
|
case "ProductSet": {
|
|
1254
|
-
if (isEmptySet(value)) return [];
|
|
1255
|
-
const factors =
|
|
1256
|
-
|
|
1257
|
-
|
|
1258
|
-
|
|
1259
|
-
)
|
|
1260
|
-
|
|
1261
|
-
return toFiniteSet(factor).elements;
|
|
1262
|
-
});
|
|
1466
|
+
if (!valueVersion.is174 && isEmptySet(value)) return [];
|
|
1467
|
+
const factors = getComponentElements(
|
|
1468
|
+
value.factors,
|
|
1469
|
+
getElements,
|
|
1470
|
+
(factor, index) =>
|
|
1471
|
+
`Attempted to enumerate a set of the form s1 \\X s2 ... \\X sn,\nbut can't enumerate s${index}:\n${formatValue(factor)}`,
|
|
1472
|
+
);
|
|
1263
1473
|
return getCartesianProduct(factors).map(createTuple);
|
|
1264
1474
|
}
|
|
1265
1475
|
case "FilteredSet":
|
|
1266
|
-
if (isOverriddenSet(value.base)) {
|
|
1476
|
+
if (!isSetValue(value.base) || isOverriddenSet(value.base)) {
|
|
1267
1477
|
throw new TlaEvaluationError(
|
|
1268
1478
|
`Attempted to enumerate { x \\in S : p(x) } when S:\n${formatValue(value.base)}\nis not enumerable`,
|
|
1269
1479
|
);
|
|
@@ -1278,7 +1488,7 @@ const enumerateSet = (value: Value): Value[] => {
|
|
|
1278
1488
|
case "SetOperation": {
|
|
1279
1489
|
if (
|
|
1280
1490
|
value.operator === "\\cup" &&
|
|
1281
|
-
(
|
|
1491
|
+
(!isTlcEnumerable(value.left) || !isTlcEnumerable(value.right))
|
|
1282
1492
|
) {
|
|
1283
1493
|
throw new TlaEvaluationError(
|
|
1284
1494
|
`Attempted to enumerate S \\cup T when S:\n${formatValue(value.left)}\nand T:\n${formatValue(value.right)}\nare not both enumerable`,
|
|
@@ -1286,21 +1496,21 @@ const enumerateSet = (value: Value): Value[] => {
|
|
|
1286
1496
|
}
|
|
1287
1497
|
if (
|
|
1288
1498
|
value.operator === "\\cap" &&
|
|
1289
|
-
|
|
1290
|
-
|
|
1499
|
+
!isTlcEnumerable(value.left) &&
|
|
1500
|
+
!isTlcEnumerable(value.right)
|
|
1291
1501
|
) {
|
|
1292
1502
|
throw new TlaEvaluationError(
|
|
1293
1503
|
`Attempted to enumerate S \\cap T when neither S:\n${formatValue(value.left)}\nnor T:\n${formatValue(value.right)}\nis enumerable`,
|
|
1294
1504
|
);
|
|
1295
1505
|
}
|
|
1296
|
-
if (value.operator === "\\" &&
|
|
1506
|
+
if (value.operator === "\\" && !isTlcEnumerable(value.left)) {
|
|
1297
1507
|
throw new TlaEvaluationError(
|
|
1298
1508
|
`Attempted to enumerate S \\ T when S:\n${formatValue(value.left)}\nis not enumerable.`,
|
|
1299
1509
|
);
|
|
1300
1510
|
}
|
|
1301
1511
|
if (value.operator === "\\cup")
|
|
1302
1512
|
return unionSorted(toFiniteSet(value.left), toFiniteSet(value.right)).elements;
|
|
1303
|
-
const isLeftEnumerated = value.operator === "\\" ||
|
|
1513
|
+
const isLeftEnumerated = value.operator === "\\" || isTlcEnumerable(value.left);
|
|
1304
1514
|
const enumerated = isLeftEnumerated ? value.left : value.right;
|
|
1305
1515
|
const other = isLeftEnumerated ? value.right : value.left;
|
|
1306
1516
|
return toFiniteSet(enumerated).elements.filter(
|
|
@@ -1326,7 +1536,10 @@ export const toFiniteSet = (value: Value): SetValue => {
|
|
|
1326
1536
|
}
|
|
1327
1537
|
const cached = typeof value === "object" ? finiteSets.get(value) : undefined;
|
|
1328
1538
|
if (cached) return cached;
|
|
1539
|
+
const sets = setTrace.sets;
|
|
1540
|
+
sets?.push(value);
|
|
1329
1541
|
const elements = enumerateSet(value);
|
|
1542
|
+
sets?.pop();
|
|
1330
1543
|
const isSorted =
|
|
1331
1544
|
typeof value === "object" &&
|
|
1332
1545
|
(value.kind === "MixedSet" ||
|
|
@@ -1344,25 +1557,60 @@ export const toFiniteSet = (value: Value): SetValue => {
|
|
|
1344
1557
|
// TLC's Enumerator for a lazy set streams the sets it combines until the set caches its elements,
|
|
1345
1558
|
// so an element that two of them share comes up once for each.
|
|
1346
1559
|
export const getStreamedElements = (value: Value): Value[] => {
|
|
1347
|
-
if (typeof value !== "object" ||
|
|
1560
|
+
if (typeof value !== "object" || cachedSets.has(value)) return toFiniteSet(value).elements;
|
|
1561
|
+
const sets = setTrace.sets;
|
|
1562
|
+
sets?.push(value);
|
|
1563
|
+
const elements = streamElements(value);
|
|
1564
|
+
sets?.pop();
|
|
1565
|
+
return elements;
|
|
1566
|
+
};
|
|
1567
|
+
|
|
1568
|
+
const getCombinedSets = (value: ObjectValue) =>
|
|
1569
|
+
value.kind === "ProductSet"
|
|
1570
|
+
? value.factors
|
|
1571
|
+
: value.kind === "RecordSet"
|
|
1572
|
+
? value.sets
|
|
1573
|
+
: value.kind === "FunctionSet"
|
|
1574
|
+
? [value.range]
|
|
1575
|
+
: undefined;
|
|
1576
|
+
|
|
1577
|
+
// Whether a set streams its elements in another order than the normalized set, so that a set of
|
|
1578
|
+
// tuples, records, or functions it is a component of has to stream too.
|
|
1579
|
+
const isStreamedApart = (value: Value): boolean => {
|
|
1580
|
+
if (typeof value !== "object" || cachedSets.has(value)) return false;
|
|
1581
|
+
if (value.kind === "Union") return true;
|
|
1582
|
+
if (value.kind === "FilteredSet") return isStreamedApart(value.base);
|
|
1583
|
+
if (value.kind === "SetOperation") {
|
|
1584
|
+
return (
|
|
1585
|
+
value.operator === "\\cup" || isStreamedApart(value.left) || isStreamedApart(value.right)
|
|
1586
|
+
);
|
|
1587
|
+
}
|
|
1588
|
+
return getCombinedSets(value)?.some(isStreamedApart) ?? false;
|
|
1589
|
+
};
|
|
1590
|
+
|
|
1591
|
+
const streamElements = (value: ObjectValue): Value[] => {
|
|
1592
|
+
// TLC streams the sets of a UNION it hasn't enumerated, so a set that appears twice there yields
|
|
1593
|
+
// its elements twice.
|
|
1348
1594
|
if (value.kind === "Union") {
|
|
1349
|
-
return getUnionSets(value).flatMap((set, index) =>
|
|
1595
|
+
return getUnionSets(value, getStreamedElements).flatMap((set, index) =>
|
|
1350
1596
|
getStreamedElements(getUnionSet(set, index, value)),
|
|
1351
1597
|
);
|
|
1352
1598
|
}
|
|
1353
1599
|
if (value.kind === "FilteredSet" && !isOverriddenSet(value.base)) {
|
|
1354
1600
|
return getStreamedElements(value.base).filter(value.test);
|
|
1355
1601
|
}
|
|
1602
|
+
const components = getCombinedSets(value);
|
|
1603
|
+
if (components?.some(isStreamedApart)) return enumerateSet(value, getStreamedElements);
|
|
1356
1604
|
if (value.kind !== "SetOperation") return toFiniteSet(value).elements;
|
|
1357
1605
|
if (value.operator === "\\cup") {
|
|
1358
|
-
return
|
|
1606
|
+
return !isTlcEnumerable(value.left) || !isTlcEnumerable(value.right)
|
|
1359
1607
|
? toFiniteSet(value).elements
|
|
1360
1608
|
: [...getStreamedElements(value.left), ...getStreamedElements(value.right)];
|
|
1361
1609
|
}
|
|
1362
|
-
const isLeftEnumerated = value.operator === "\\" ||
|
|
1610
|
+
const isLeftEnumerated = value.operator === "\\" || isTlcEnumerable(value.left);
|
|
1363
1611
|
const enumerated = isLeftEnumerated ? value.left : value.right;
|
|
1364
1612
|
const other = isLeftEnumerated ? value.right : value.left;
|
|
1365
|
-
if (
|
|
1613
|
+
if (!isTlcEnumerable(enumerated)) return toFiniteSet(value).elements;
|
|
1366
1614
|
return getStreamedElements(enumerated).filter(
|
|
1367
1615
|
(element) => isElementOf(element, other) === (value.operator === "\\cap"),
|
|
1368
1616
|
);
|
|
@@ -1399,9 +1647,13 @@ export const isEmptySet = (value: Value): boolean => {
|
|
|
1399
1647
|
}
|
|
1400
1648
|
};
|
|
1401
1649
|
|
|
1402
|
-
const getProductCardinality = (
|
|
1650
|
+
const getProductCardinality = (
|
|
1651
|
+
sets: Value[],
|
|
1652
|
+
version: TlcVersion | undefined,
|
|
1653
|
+
describe: () => string,
|
|
1654
|
+
) =>
|
|
1403
1655
|
sets.reduce<number>((product, set) => {
|
|
1404
|
-
const size = product * getCardinality(set);
|
|
1656
|
+
const size = product * getCardinality(set, version);
|
|
1405
1657
|
if (size > MAXIMUM_INTEGER) throw new TlaEvaluationError(describe());
|
|
1406
1658
|
return size;
|
|
1407
1659
|
}, 1);
|
|
@@ -1409,9 +1661,25 @@ const getProductCardinality = (sets: Value[], describe: () => string) =>
|
|
|
1409
1661
|
const describeOverflow = (value: Value) =>
|
|
1410
1662
|
`Overflow when computing the number of elements in:\n${formatValue(value)}`;
|
|
1411
1663
|
|
|
1412
|
-
|
|
1413
|
-
|
|
1664
|
+
// TLC 1.7.4 sizes every component of a set of functions, records, or tuples without first
|
|
1665
|
+
// checking whether one is empty, so an infinite component fails even beside an empty one.
|
|
1666
|
+
export const getCardinality = (value: Value, version?: TlcVersion): number => {
|
|
1667
|
+
if (typeof value !== "object") {
|
|
1668
|
+
const kind =
|
|
1669
|
+
typeof value === "number" ? "integer" : typeof value === "string" ? "string" : "boolean";
|
|
1670
|
+
throw new TlaEvaluationError(
|
|
1671
|
+
`Attempted to compute the number of elements in the ${kind} ${formatValue(value)}.`,
|
|
1672
|
+
);
|
|
1673
|
+
}
|
|
1414
1674
|
switch (value.kind) {
|
|
1675
|
+
case "ModelValue":
|
|
1676
|
+
throw new TlaEvaluationError(
|
|
1677
|
+
`Attempted to compute the number of elements in the model value ${formatValue(value)}.`,
|
|
1678
|
+
);
|
|
1679
|
+
case "Function":
|
|
1680
|
+
return value.domain.length;
|
|
1681
|
+
case "LazyFunction":
|
|
1682
|
+
return getCardinality(value.domain, version);
|
|
1415
1683
|
case "Interval": {
|
|
1416
1684
|
const size = Math.max(0, value.high - value.low + 1);
|
|
1417
1685
|
if (size > MAXIMUM_INTEGER) {
|
|
@@ -1427,16 +1695,19 @@ export const getCardinality = (value: Value): number => {
|
|
|
1427
1695
|
`Attempted to compute the number of elements in the overridden value ${formatValue(value)}.`,
|
|
1428
1696
|
);
|
|
1429
1697
|
case "Subset": {
|
|
1430
|
-
const size = getCardinality(value.base);
|
|
1698
|
+
const size = getCardinality(value.base, version);
|
|
1431
1699
|
if (size >= 31) throw new TlaEvaluationError(describeOverflow(value));
|
|
1432
1700
|
return 2 ** size;
|
|
1433
1701
|
}
|
|
1434
1702
|
case "FunctionSet": {
|
|
1435
|
-
if (
|
|
1436
|
-
|
|
1437
|
-
|
|
1438
|
-
|
|
1439
|
-
|
|
1703
|
+
if (version !== "1.7.4") {
|
|
1704
|
+
if (isEmptySet(value.domain)) return 1;
|
|
1705
|
+
if (isEmptySet(value.range)) return 0;
|
|
1706
|
+
if (getCardinality(value.range, version) === 1) return 1;
|
|
1707
|
+
}
|
|
1708
|
+
const domainSize = getCardinality(value.domain, version);
|
|
1709
|
+
const rangeSize = getCardinality(value.range, version);
|
|
1710
|
+
if (rangeSize <= 1) return domainSize === 0 ? 1 : rangeSize;
|
|
1440
1711
|
const size = { value: 1 };
|
|
1441
1712
|
for (let index = 0; index < domainSize; index++) {
|
|
1442
1713
|
size.value *= rangeSize;
|
|
@@ -1445,15 +1716,17 @@ export const getCardinality = (value: Value): number => {
|
|
|
1445
1716
|
return size.value;
|
|
1446
1717
|
}
|
|
1447
1718
|
case "RecordSet":
|
|
1448
|
-
if (isEmptySet(value)) return 0;
|
|
1449
|
-
return getProductCardinality(value.sets, () => describeOverflow(value));
|
|
1719
|
+
if (version !== "1.7.4" && isEmptySet(value)) return 0;
|
|
1720
|
+
return getProductCardinality(value.sets, version, () => describeOverflow(value));
|
|
1450
1721
|
case "ProductSet":
|
|
1451
|
-
if (isEmptySet(value)) return 0;
|
|
1722
|
+
if (version !== "1.7.4" && isEmptySet(value)) return 0;
|
|
1452
1723
|
return getProductCardinality(
|
|
1453
1724
|
value.factors,
|
|
1725
|
+
version,
|
|
1454
1726
|
() => `Overflow when computing the number of elements in ${formatValue(value)}`,
|
|
1455
1727
|
);
|
|
1456
1728
|
default:
|
|
1729
|
+
cacheSet(value);
|
|
1457
1730
|
return toFiniteSet(value).elements.length;
|
|
1458
1731
|
}
|
|
1459
1732
|
};
|
|
@@ -1528,11 +1801,11 @@ export const isFiniteSet = (value: Value): boolean => {
|
|
|
1528
1801
|
}
|
|
1529
1802
|
};
|
|
1530
1803
|
|
|
1531
|
-
const findIndex = (sortedValues: Value[], target: Value) => {
|
|
1804
|
+
const findIndex = (sortedValues: Value[], target: Value, compare = compareValues) => {
|
|
1532
1805
|
const bounds = { low: 0, high: sortedValues.length - 1 };
|
|
1533
1806
|
while (bounds.low <= bounds.high) {
|
|
1534
1807
|
const middle = (bounds.low + bounds.high) >> 1;
|
|
1535
|
-
const comparison =
|
|
1808
|
+
const comparison = compare(sortedValues[middle], target);
|
|
1536
1809
|
if (comparison === 0) return middle;
|
|
1537
1810
|
if (comparison < 0) bounds.low = middle + 1;
|
|
1538
1811
|
else bounds.high = middle - 1;
|
|
@@ -1548,33 +1821,78 @@ export const getSequenceElements = (value: Value): Value[] | undefined => {
|
|
|
1548
1821
|
: undefined;
|
|
1549
1822
|
};
|
|
1550
1823
|
|
|
1551
|
-
const describeMembership = (element: Value, set: Value) =>
|
|
1552
|
-
`Attempted to check if the value ${formatValue(element)} is an element of ${formatValue(set)}`;
|
|
1553
|
-
|
|
1554
1824
|
const describeNonSetMembership = (element: Value, value: Value) => {
|
|
1555
1825
|
const prefix = `Attempted to check if the value:\n${formatValue(element)}\nis an element of the`;
|
|
1556
1826
|
if (!isFunctionValue(value)) return `${prefix} ${describeKind(value)} ${formatValue(value)}`;
|
|
1557
|
-
const
|
|
1558
|
-
|
|
1559
|
-
if (domain.length > 0 && domain.every((key) => typeof key === "string")) {
|
|
1827
|
+
const functionClass = getFunctionClass(value);
|
|
1828
|
+
if (functionClass === "record") {
|
|
1560
1829
|
return `Attempted to check if element:\n${formatValue(element)}\nis in the record:\n${formatValue(value)}`;
|
|
1561
1830
|
}
|
|
1562
|
-
if (
|
|
1563
|
-
return "Attempted to check set membership in a tuple value.";
|
|
1564
|
-
}
|
|
1831
|
+
if (functionClass === "tuple") return "Attempted to check set membership in a tuple value.";
|
|
1565
1832
|
return `${prefix} function ${formatValue(value)}`;
|
|
1566
1833
|
};
|
|
1567
1834
|
|
|
1835
|
+
// The call stack of the replay, which a failed fast path leaves frozen.
|
|
1836
|
+
interface TracedCallStack {
|
|
1837
|
+
expressions: unknown[];
|
|
1838
|
+
isFrozen: boolean;
|
|
1839
|
+
fingerprint?: unknown;
|
|
1840
|
+
}
|
|
1841
|
+
|
|
1842
|
+
// The sets whose membership is being checked or whose elements are being enumerated, and the
|
|
1843
|
+
// members being compared, outermost first, while TLC's CallStackTool replays a computation. A failed
|
|
1844
|
+
// check or enumeration leaves the values it was in, each of which TLC adds to the
|
|
1845
|
+
// FingerprintException when it has a source.
|
|
1846
|
+
export const setTrace: { sets: Value[] | undefined; callStack?: TracedCallStack } = {
|
|
1847
|
+
sets: undefined,
|
|
1848
|
+
};
|
|
1849
|
+
|
|
1850
|
+
// Takes a fast path, and computes as TLC does where it fails. TLC never takes the fast path, so
|
|
1851
|
+
// the failure's leftovers in the replay's trace go first.
|
|
1852
|
+
export const computeLikeTlcOnFailure = <Result>(
|
|
1853
|
+
compute: () => Result,
|
|
1854
|
+
computeLikeTlc: (error: TlaEvaluationError) => Result,
|
|
1855
|
+
): Result => {
|
|
1856
|
+
const sets = setTrace.sets;
|
|
1857
|
+
const callStack = setTrace.callStack;
|
|
1858
|
+
const depth = sets?.length ?? 0;
|
|
1859
|
+
const trace = callStack && { ...callStack, length: callStack.expressions.length };
|
|
1860
|
+
try {
|
|
1861
|
+
return compute();
|
|
1862
|
+
} catch (error) {
|
|
1863
|
+
if (!(error instanceof TlaEvaluationError)) throw error;
|
|
1864
|
+
if (sets) sets.length = depth;
|
|
1865
|
+
if (callStack && trace) {
|
|
1866
|
+
callStack.expressions.length = trace.length;
|
|
1867
|
+
callStack.isFrozen = trace.isFrozen;
|
|
1868
|
+
callStack.fingerprint = trace.fingerprint;
|
|
1869
|
+
}
|
|
1870
|
+
return computeLikeTlc(error);
|
|
1871
|
+
}
|
|
1872
|
+
};
|
|
1873
|
+
|
|
1568
1874
|
export const isElementOf = (element: Value, set: Value): boolean => {
|
|
1875
|
+
const sets = setTrace.sets;
|
|
1876
|
+
if (sets === undefined) return isElementOfSet(element, set);
|
|
1877
|
+
sets.push(set);
|
|
1878
|
+
const isElement = isElementOfSet(element, set);
|
|
1879
|
+
sets.pop();
|
|
1880
|
+
return isElement;
|
|
1881
|
+
};
|
|
1882
|
+
|
|
1883
|
+
const isElementOfSet = (element: Value, set: Value): boolean => {
|
|
1569
1884
|
if (!isSetValue(set)) throw new TlaEvaluationError(describeNonSetMembership(element, set));
|
|
1570
1885
|
switch (set.kind) {
|
|
1571
1886
|
case "Set":
|
|
1572
|
-
|
|
1573
|
-
|
|
1574
|
-
|
|
1575
|
-
|
|
1576
|
-
|
|
1577
|
-
|
|
1887
|
+
// SetEnumValue.member compares the element with the set's.
|
|
1888
|
+
cacheSet(element);
|
|
1889
|
+
return computeLikeTlcOnFailure(
|
|
1890
|
+
() => findIndex(set.elements, element) !== -1,
|
|
1891
|
+
() =>
|
|
1892
|
+
normalizedSets.has(set)
|
|
1893
|
+
? searchLikeTlc(element, set.elements).isFound
|
|
1894
|
+
: isElementOfLikeTlc(element, set.elements),
|
|
1895
|
+
);
|
|
1578
1896
|
case "MixedSet":
|
|
1579
1897
|
return isElementOfLikeTlc(element, set.elements);
|
|
1580
1898
|
case "Interval":
|
|
@@ -1598,12 +1916,21 @@ export const isElementOf = (element: Value, set: Value): boolean => {
|
|
|
1598
1916
|
return set.name !== "Nat" || (typeof element === "number" && element >= 0);
|
|
1599
1917
|
}
|
|
1600
1918
|
case "Subset":
|
|
1601
|
-
|
|
1919
|
+
// SubsetValue.member fails on any value that is not Enumerable, model values and the sets a
|
|
1920
|
+
// Java class overrides included.
|
|
1921
|
+
if (!isSetValue(element) || isOverriddenSet(element)) {
|
|
1922
|
+
throw new TlaEvaluationError(
|
|
1923
|
+
`Attempted to check if the non-enumerable value\n${prettyPrint(formatValue(element))}\nis element of\n${prettyPrint(formatValue(set))}`,
|
|
1924
|
+
);
|
|
1925
|
+
}
|
|
1602
1926
|
return toFiniteSet(element).elements.every((item) => isElementOf(item, set.base));
|
|
1603
1927
|
case "FunctionSet": {
|
|
1604
1928
|
if (!isFunctionValue(element)) {
|
|
1605
1929
|
if (isModelValue(element)) return false;
|
|
1606
|
-
|
|
1930
|
+
// SetOfFcnsValue.member prints the element without Values.ppr.
|
|
1931
|
+
throw new TlaEvaluationError(
|
|
1932
|
+
`Attempted to check if \n${formatValue(element)}\nwhich is not a TLC function value, is in the set of functions:\n${prettyPrint(formatValue(set))}`,
|
|
1933
|
+
);
|
|
1607
1934
|
}
|
|
1608
1935
|
const functionValue = toFiniteFunction(element);
|
|
1609
1936
|
const low = getIntervalLow(functionValue.domain);
|
|
@@ -1668,7 +1995,10 @@ export const isElementOf = (element: Value, set: Value): boolean => {
|
|
|
1668
1995
|
const elements = getSequenceElements(element);
|
|
1669
1996
|
if (elements === undefined) {
|
|
1670
1997
|
if (isModelValue(element)) return false;
|
|
1671
|
-
|
|
1998
|
+
// Sequences.member raises TLC_MODULE_CHECK_MEMBER_OF.
|
|
1999
|
+
throw new TlaEvaluationError(
|
|
2000
|
+
`Attempted to check if the value:\n${prettyPrint(formatValue(element))}\nis an element of ${prettyPrint(formatValue(set))}.`,
|
|
2001
|
+
);
|
|
1672
2002
|
}
|
|
1673
2003
|
return elements.every((item) => isElementOf(item, set.base));
|
|
1674
2004
|
}
|
|
@@ -1701,27 +2031,59 @@ export const toFiniteFunction = (value: Value): FunctionValue => {
|
|
|
1701
2031
|
if (typeof value === "object" && value.kind === "LazyFunction") {
|
|
1702
2032
|
if (!isEnumerable(value.domain)) getCardinality(value.domain);
|
|
1703
2033
|
const domain = getFunctionDomain(value.domain);
|
|
1704
|
-
return
|
|
1705
|
-
|
|
1706
|
-
|
|
2034
|
+
return setFunctionClass(
|
|
2035
|
+
createSortedFunction(
|
|
2036
|
+
domain,
|
|
2037
|
+
domain.map((key) => value.apply(key)),
|
|
2038
|
+
),
|
|
2039
|
+
getFunctionClass(value),
|
|
1707
2040
|
);
|
|
1708
2041
|
}
|
|
1709
2042
|
throw new TlaEvaluationError(`Expected a function but found ${formatValue(value)}`);
|
|
1710
2043
|
};
|
|
1711
2044
|
|
|
1712
|
-
const
|
|
1713
|
-
|
|
1714
|
-
|
|
1715
|
-
|
|
2045
|
+
export const describeMissingArgument = (
|
|
2046
|
+
functionValue: Value,
|
|
2047
|
+
argument: Value,
|
|
2048
|
+
version?: TlcVersion,
|
|
1716
2049
|
) => {
|
|
1717
|
-
|
|
1718
|
-
|
|
2050
|
+
const shown = prettyPrint(formatValue(functionValue));
|
|
2051
|
+
const shownArgument = prettyPrint(formatValue(argument));
|
|
2052
|
+
const is174 = version === "1.7.4";
|
|
2053
|
+
switch (getFunctionClass(functionValue)) {
|
|
2054
|
+
case "lambda":
|
|
2055
|
+
return `In applying the function\n${shown},\nthe first argument is:\n${shownArgument}\nwhich is not in its domain.\n`;
|
|
2056
|
+
case "tuple":
|
|
2057
|
+
if (typeof argument !== "number") {
|
|
2058
|
+
return is174
|
|
2059
|
+
? "Attempted to apply tuple to a non-integer argument."
|
|
2060
|
+
: `Attempted to access tuple at a non integral index: ${shownArgument}`;
|
|
2061
|
+
}
|
|
2062
|
+
return is174
|
|
2063
|
+
? `Attempted to apply tuple\n${shown}\nto integer ${argument} which is out of domain.`
|
|
2064
|
+
: `Attempted to access index ${argument} of tuple\n${shown}\nwhich is out of bounds.`;
|
|
2065
|
+
case "record":
|
|
2066
|
+
if (typeof argument !== "string") {
|
|
2067
|
+
return is174
|
|
2068
|
+
? `Attempted to apply record to a non-string value ${shownArgument}.`
|
|
2069
|
+
: `Attempted to access record by a non-string argument: ${shownArgument}`;
|
|
2070
|
+
}
|
|
2071
|
+
return is174
|
|
2072
|
+
? `Attempted to apply the record\n${shown}\nto nonexistent record field ${argument}.`
|
|
2073
|
+
: `Attempted to access nonexistent field '${argument}' of record\n${shown}`;
|
|
2074
|
+
default:
|
|
2075
|
+
return `Attempted to apply function:\n${shown}\nto argument ${shownArgument}, which is not in the domain of the function.`;
|
|
2076
|
+
}
|
|
1719
2077
|
};
|
|
1720
2078
|
|
|
1721
|
-
|
|
1722
|
-
|
|
1723
|
-
|
|
1724
|
-
|
|
2079
|
+
// TLC 1.7.4 words a key of the wrong type in an EXCEPT, which selects rather than applies, apart.
|
|
2080
|
+
const describeExceptKey = (functionValue: FunctionValue, argument: Value) => {
|
|
2081
|
+
if (!valueVersion.is174) return describeMissingArgument(functionValue, argument);
|
|
2082
|
+
const shown = prettyPrint(formatValue(argument));
|
|
2083
|
+
return getFunctionClass(functionValue) === "tuple"
|
|
2084
|
+
? `Attempted to apply tuple to a non-integer argument ${shown}.`
|
|
2085
|
+
: `Attempted to apply record to a non-string argument ${shown}.`;
|
|
2086
|
+
};
|
|
1725
2087
|
|
|
1726
2088
|
const findKeyIndex = (domain: Value[], argument: Value) => {
|
|
1727
2089
|
const first = domain[0];
|
|
@@ -1736,15 +2098,57 @@ const findKeyIndex = (domain: Value[], argument: Value) => {
|
|
|
1736
2098
|
return findIndex(domain, argument);
|
|
1737
2099
|
};
|
|
1738
2100
|
|
|
2101
|
+
export const createNonIntegerKeyError = (argument: Value) =>
|
|
2102
|
+
new TlaEvaluationError(
|
|
2103
|
+
`Attempted to apply function with integer domain to the non-integer argument ${prettyPrint(formatValue(argument))}`,
|
|
2104
|
+
);
|
|
2105
|
+
|
|
2106
|
+
// TLC's FcnRcdValue searches a domain this small linearly with equals, and a larger normalized one by
|
|
2107
|
+
// binary search with compareTo.
|
|
2108
|
+
const LINEAR_SEARCH_LIMIT = 32;
|
|
2109
|
+
|
|
2110
|
+
// TLC looks a key up by the Java class of the function: a tuple or a record rejects a key of the
|
|
2111
|
+
// wrong type, and another function rejects a non-integer for a domain it keeps as an interval, which
|
|
2112
|
+
// TLC 1.7.4 doesn't. A key of another type than the domain's keys otherwise fails TLC's comparison.
|
|
2113
|
+
const findKeyIndexLikeTlc = (
|
|
2114
|
+
functionValue: FunctionValue,
|
|
2115
|
+
argument: Value,
|
|
2116
|
+
describeWrongKey: (functionValue: FunctionValue, argument: Value) => string,
|
|
2117
|
+
) => {
|
|
2118
|
+
const domain = functionValue.domain;
|
|
2119
|
+
if (typeof argument !== typeof domain[0]) {
|
|
2120
|
+
const functionClass = getFunctionClass(functionValue);
|
|
2121
|
+
const keyType =
|
|
2122
|
+
functionClass === "tuple" ? "number" : functionClass === "record" ? "string" : undefined;
|
|
2123
|
+
if (keyType !== undefined && typeof argument !== keyType) {
|
|
2124
|
+
throw new TlaEvaluationError(describeWrongKey(functionValue, argument));
|
|
2125
|
+
}
|
|
2126
|
+
if (keyType === undefined && !valueVersion.is174 && isIntervalDomain(domain)) {
|
|
2127
|
+
throw createNonIntegerKeyError(argument);
|
|
2128
|
+
}
|
|
2129
|
+
}
|
|
2130
|
+
return computeLikeTlcOnFailure(
|
|
2131
|
+
() => findKeyIndex(domain, argument),
|
|
2132
|
+
(error) => {
|
|
2133
|
+
if (valueVersion.is174 || domain.length < LINEAR_SEARCH_LIMIT) {
|
|
2134
|
+
domain.forEach((key) => equalsLikeTlc(key, argument));
|
|
2135
|
+
} else {
|
|
2136
|
+
findIndex(domain, argument, compareLikeTlc);
|
|
2137
|
+
}
|
|
2138
|
+
throw error;
|
|
2139
|
+
},
|
|
2140
|
+
);
|
|
2141
|
+
};
|
|
2142
|
+
|
|
1739
2143
|
export const applyFunction = (
|
|
1740
2144
|
functionValue: Value,
|
|
1741
2145
|
argument: Value,
|
|
1742
|
-
describeMissing?: (functionValue: FunctionValue) => string,
|
|
2146
|
+
describeMissing?: (functionValue: FunctionValue, argument: Value) => string,
|
|
1743
2147
|
): Value => {
|
|
1744
2148
|
if (typeof functionValue === "object" && functionValue.kind === "LazyFunction") {
|
|
1745
2149
|
if (!isElementOf(argument, functionValue.domain)) {
|
|
1746
2150
|
throw new TlaEvaluationError(
|
|
1747
|
-
|
|
2151
|
+
getFunctionClass(functionValue) === "lambda"
|
|
1748
2152
|
? describeMissingArgument(functionValue, argument)
|
|
1749
2153
|
: `Attempted to apply a function to ${formatValue(argument)}, which is not in its domain`,
|
|
1750
2154
|
);
|
|
@@ -1756,12 +2160,9 @@ export const applyFunction = (
|
|
|
1756
2160
|
`Attempted to apply ${formatValue(functionValue)}, which is not a function`,
|
|
1757
2161
|
);
|
|
1758
2162
|
}
|
|
1759
|
-
const
|
|
1760
|
-
|
|
1761
|
-
|
|
1762
|
-
describeMissing?.(functionValue) ?? describeMissingArgument(functionValue, argument),
|
|
1763
|
-
);
|
|
1764
|
-
}
|
|
2163
|
+
const describe = describeMissing ?? describeMissingArgument;
|
|
2164
|
+
const position = findKeyIndexLikeTlc(functionValue, argument, describe);
|
|
2165
|
+
if (position === -1) throw new TlaEvaluationError(describe(functionValue, argument));
|
|
1765
2166
|
return functionValue.range[position];
|
|
1766
2167
|
};
|
|
1767
2168
|
|
|
@@ -1790,28 +2191,45 @@ export const updateFunction = (
|
|
|
1790
2191
|
if (isLazy) {
|
|
1791
2192
|
if (!isElementOf(argument, functionValue.domain)) return functionValue;
|
|
1792
2193
|
const updated = update(functionValue.apply(argument));
|
|
1793
|
-
return
|
|
1794
|
-
|
|
1795
|
-
|
|
1796
|
-
|
|
1797
|
-
|
|
1798
|
-
|
|
2194
|
+
return setFunctionClass<LazyFunctionValue>(
|
|
2195
|
+
{
|
|
2196
|
+
kind: "LazyFunction",
|
|
2197
|
+
domain: functionValue.domain,
|
|
2198
|
+
apply: (key) => (isEqualLikeTlc(argument, key) ? updated : functionValue.apply(key)),
|
|
2199
|
+
source: functionValue.source,
|
|
2200
|
+
},
|
|
2201
|
+
getFunctionClass(functionValue),
|
|
2202
|
+
);
|
|
2203
|
+
}
|
|
2204
|
+
if (!isFunctionValue(functionValue)) {
|
|
2205
|
+
throw new TlaEvaluationError(
|
|
2206
|
+
`Attempted to apply EXCEPT construct to the value ${prettyPrint(formatValue(functionValue))}.`,
|
|
2207
|
+
);
|
|
1799
2208
|
}
|
|
1800
2209
|
const finite = toFiniteFunction(functionValue);
|
|
1801
|
-
const position =
|
|
2210
|
+
const position = findKeyIndexLikeTlc(finite, argument, describeExceptKey);
|
|
1802
2211
|
if (position === -1) return finite;
|
|
1803
2212
|
const range = [...finite.range];
|
|
1804
2213
|
const previous = finite.range[position];
|
|
1805
2214
|
const next = update(previous);
|
|
1806
2215
|
range[position] = next;
|
|
1807
|
-
const updated =
|
|
2216
|
+
const updated = setFunctionClass(
|
|
2217
|
+
createSortedFunction(finite.domain, range),
|
|
2218
|
+
getFunctionClass(finite),
|
|
2219
|
+
);
|
|
1808
2220
|
updated.writtenKeys = finite.writtenKeys;
|
|
1809
|
-
if (finite.hash !== 0) {
|
|
1810
|
-
const
|
|
1811
|
-
|
|
1812
|
-
|
|
1813
|
-
|
|
1814
|
-
|
|
2221
|
+
if (finite.hash !== 0 && finite.hash !== UNFINGERPRINTABLE_HASH) {
|
|
2222
|
+
const nextHash = getValueHash(next);
|
|
2223
|
+
if (nextHash !== UNFINGERPRINTABLE_HASH) {
|
|
2224
|
+
const keyHash = getValueHash(finite.domain[position]);
|
|
2225
|
+
updated.hash =
|
|
2226
|
+
previous === next
|
|
2227
|
+
? finite.hash
|
|
2228
|
+
: (finite.hash -
|
|
2229
|
+
getEntryContribution(keyHash, getValueHash(previous)) +
|
|
2230
|
+
getEntryContribution(keyHash, nextHash)) |
|
|
2231
|
+
0;
|
|
2232
|
+
}
|
|
1815
2233
|
}
|
|
1816
2234
|
if (finite.fingerprint !== 0) {
|
|
1817
2235
|
const key = finite.domain[position];
|
|
@@ -1848,32 +2266,103 @@ const hashString = (value: string) => {
|
|
|
1848
2266
|
const SET_HASH_SEED = 0x73a5c3e1;
|
|
1849
2267
|
const FUNCTION_HASH_SEED = 0x66d1b4f7;
|
|
1850
2268
|
|
|
1851
|
-
const getElementContribution = (
|
|
1852
|
-
finalizeHash((
|
|
2269
|
+
const getElementContribution = (elementHash: number) =>
|
|
2270
|
+
finalizeHash((elementHash + 0x9e3779b9) | 0);
|
|
1853
2271
|
|
|
1854
|
-
const getEntryContribution = (
|
|
1855
|
-
finalizeHash((Math.imul(
|
|
2272
|
+
const getEntryContribution = (keyHash: number, valueHash: number) =>
|
|
2273
|
+
finalizeHash((Math.imul(keyHash, 0x27d4eb2d) + valueHash) | 0);
|
|
2274
|
+
|
|
2275
|
+
// The hash of each value that TLC fails to fingerprint, such as Nat or a set that holds it. Calls
|
|
2276
|
+
// with such a value as an argument still share their result, and a state that holds one fails
|
|
2277
|
+
// when TLC fingerprints it.
|
|
2278
|
+
const UNFINGERPRINTABLE_HASH = 0x2f6b1c4d;
|
|
1856
2279
|
|
|
1857
2280
|
const computeValueHash = (value: ObjectValue) => {
|
|
1858
2281
|
if (value.kind === "ModelValue") return finalizeHash(combineHash(hashString(value.name), 0x6d));
|
|
1859
2282
|
if (isSetValue(value)) {
|
|
1860
|
-
if (!isEnumerable(value)) return
|
|
2283
|
+
if (!isEnumerable(value)) return UNFINGERPRINTABLE_HASH;
|
|
1861
2284
|
const elements = toFiniteSet(value).elements;
|
|
1862
2285
|
let hash = SET_HASH_SEED;
|
|
1863
2286
|
for (let index = 0; index < elements.length; index++) {
|
|
1864
|
-
|
|
2287
|
+
const elementHash = getValueHash(elements[index]);
|
|
2288
|
+
if (elementHash === UNFINGERPRINTABLE_HASH) return UNFINGERPRINTABLE_HASH;
|
|
2289
|
+
hash = (hash + getElementContribution(elementHash)) | 0;
|
|
1865
2290
|
}
|
|
1866
2291
|
return hash;
|
|
1867
2292
|
}
|
|
2293
|
+
if (value.kind === "LazyFunction" && !isEnumerable(value.domain)) return UNFINGERPRINTABLE_HASH;
|
|
1868
2294
|
const functionValue = toFiniteFunction(value);
|
|
1869
2295
|
let hash = FUNCTION_HASH_SEED;
|
|
1870
2296
|
for (let index = 0; index < functionValue.domain.length; index++) {
|
|
1871
|
-
|
|
1872
|
-
|
|
2297
|
+
const keyHash = getValueHash(functionValue.domain[index]);
|
|
2298
|
+
const itemHash = getValueHash(functionValue.range[index]);
|
|
2299
|
+
if (keyHash === UNFINGERPRINTABLE_HASH || itemHash === UNFINGERPRINTABLE_HASH) {
|
|
2300
|
+
return UNFINGERPRINTABLE_HASH;
|
|
2301
|
+
}
|
|
2302
|
+
hash = (hash + getEntryContribution(keyHash, itemHash)) | 0;
|
|
1873
2303
|
}
|
|
1874
2304
|
return hash;
|
|
1875
2305
|
};
|
|
1876
2306
|
|
|
2307
|
+
// TLC's fingerPrint enumerates each set and function a value holds, and fails on Nat, Seq(S) and
|
|
2308
|
+
// the like, which it never enumerates.
|
|
2309
|
+
const fingerprintValue = (value: Value): void => {
|
|
2310
|
+
if (typeof value !== "object" || value.kind === "ModelValue") return;
|
|
2311
|
+
if (value.kind === "InfiniteSet" || value.kind === "SequenceSet") {
|
|
2312
|
+
throw new TlaEvaluationError(
|
|
2313
|
+
`TLC has found a state in which the value of a variable contains ${formatValue(value)}`,
|
|
2314
|
+
);
|
|
2315
|
+
}
|
|
2316
|
+
if (isSetValue(value)) {
|
|
2317
|
+
toFiniteSet(value).elements.forEach(fingerprintValue);
|
|
2318
|
+
return;
|
|
2319
|
+
}
|
|
2320
|
+
const functionValue = toFiniteFunction(value);
|
|
2321
|
+
functionValue.domain.forEach(fingerprintValue);
|
|
2322
|
+
functionValue.range.forEach(fingerprintValue);
|
|
2323
|
+
};
|
|
2324
|
+
|
|
2325
|
+
// The error TLC raises as it fingerprints a value: one that hashing the value raises, as for a set
|
|
2326
|
+
// too large to enumerate, or one of a value with the hash of the values TLC fails on.
|
|
2327
|
+
export const getFingerprintError = (value: Value) => {
|
|
2328
|
+
if (typeof value !== "object" || value.kind === "ModelValue") return undefined;
|
|
2329
|
+
try {
|
|
2330
|
+
if (getValueHash(value) === UNFINGERPRINTABLE_HASH) fingerprintValue(value);
|
|
2331
|
+
return undefined;
|
|
2332
|
+
} catch (error) {
|
|
2333
|
+
if (!(error instanceof TlaEvaluationError)) throw error;
|
|
2334
|
+
return error;
|
|
2335
|
+
}
|
|
2336
|
+
};
|
|
2337
|
+
|
|
2338
|
+
// The values a value holds, which TLC fingerprints as it fingerprints the value.
|
|
2339
|
+
export const getHeldValues = (value: ObjectValue): Value[] => {
|
|
2340
|
+
switch (value.kind) {
|
|
2341
|
+
case "Set":
|
|
2342
|
+
case "MixedSet":
|
|
2343
|
+
return value.elements;
|
|
2344
|
+
case "Function":
|
|
2345
|
+
return [...value.domain, ...value.range];
|
|
2346
|
+
case "Subset":
|
|
2347
|
+
case "SequenceSet":
|
|
2348
|
+
case "FilteredSet":
|
|
2349
|
+
case "Union":
|
|
2350
|
+
return [value.base];
|
|
2351
|
+
case "FunctionSet":
|
|
2352
|
+
return [value.domain, value.range];
|
|
2353
|
+
case "RecordSet":
|
|
2354
|
+
return value.sets;
|
|
2355
|
+
case "ProductSet":
|
|
2356
|
+
return value.factors;
|
|
2357
|
+
case "SetOperation":
|
|
2358
|
+
return [value.left, value.right];
|
|
2359
|
+
case "LazyFunction":
|
|
2360
|
+
return [value.domain];
|
|
2361
|
+
default:
|
|
2362
|
+
return [];
|
|
2363
|
+
}
|
|
2364
|
+
};
|
|
2365
|
+
|
|
1877
2366
|
export const getValueHash = (value: Value): number => {
|
|
1878
2367
|
if (typeof value === "number") return finalizeHash(value ^ 0x5bd1e995);
|
|
1879
2368
|
if (typeof value === "boolean") return value ? 0x2b7e1516 : 0x28aed2a6;
|
|
@@ -2048,7 +2537,9 @@ const formatLazySet = (value: LazySetValue, isStrict: boolean): string => {
|
|
|
2048
2537
|
case "SetOperation":
|
|
2049
2538
|
return `${format(value.left)} ${value.operator} ${format(value.right)}`;
|
|
2050
2539
|
case "FilteredSet":
|
|
2051
|
-
return
|
|
2540
|
+
return value.source
|
|
2541
|
+
? `{${value.source.names} \\in ${format(value.base)} : <expression ${value.source.predicate}> }`
|
|
2542
|
+
: `{x \\in ${format(value.base)} : ...}`;
|
|
2052
2543
|
case "Union":
|
|
2053
2544
|
return formatUnion(value, isStrict);
|
|
2054
2545
|
}
|
|
@@ -2061,6 +2552,17 @@ const isFieldName = (name: string) =>
|
|
|
2061
2552
|
/\p{L}/u.test(name) &&
|
|
2062
2553
|
(name.length < 4 || !/^[WS]F_/.test(name));
|
|
2063
2554
|
|
|
2555
|
+
// FcnLambdaValue#toString prints a function it fails to enumerate as its parameters and body.
|
|
2556
|
+
const toPrintedFunction = (value: LazyFunctionValue) => {
|
|
2557
|
+
if (!isEnumerable(value.domain)) return undefined;
|
|
2558
|
+
try {
|
|
2559
|
+
return toFiniteFunction(value);
|
|
2560
|
+
} catch (error) {
|
|
2561
|
+
if (error instanceof TlaEvaluationError) return undefined;
|
|
2562
|
+
throw error;
|
|
2563
|
+
}
|
|
2564
|
+
};
|
|
2565
|
+
|
|
2064
2566
|
export const formatValue = (value: Value, isStrict = false, isNormalized = false): string => {
|
|
2065
2567
|
const format = (inner: Value) => formatValue(inner, isStrict, isNormalized);
|
|
2066
2568
|
if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
|
|
@@ -2092,27 +2594,53 @@ export const formatValue = (value: Value, isStrict = false, isNormalized = false
|
|
|
2092
2594
|
return `Seq(${format(value.base)})`;
|
|
2093
2595
|
case "Function":
|
|
2094
2596
|
case "LazyFunction": {
|
|
2095
|
-
|
|
2096
|
-
|
|
2597
|
+
const functionValue = value.kind === "LazyFunction" ? toPrintedFunction(value) : value;
|
|
2598
|
+
if (functionValue === undefined) {
|
|
2599
|
+
const source = value.kind === "LazyFunction" ? value.source : undefined;
|
|
2097
2600
|
if (!source) return "<function>";
|
|
2098
2601
|
const parameters = source.parameters
|
|
2099
2602
|
.map((parameter) => `${parameter.name} \\in ${formatValue(parameter.domain)}`)
|
|
2100
2603
|
.join(", ");
|
|
2101
2604
|
return `[${parameters} |-> <expression ${source.body}>]`;
|
|
2102
2605
|
}
|
|
2103
|
-
|
|
2606
|
+
if (
|
|
2607
|
+
functionValue.domain.length === 0 &&
|
|
2608
|
+
valueVersion.is174 &&
|
|
2609
|
+
getFunctionClass(value) !== "tuple"
|
|
2610
|
+
) {
|
|
2611
|
+
return "<< >>";
|
|
2612
|
+
}
|
|
2613
|
+
// TLC normalizes a lambda's domain to print it, but evaluates its body afterward.
|
|
2614
|
+
const formatRange = (inner: Value) =>
|
|
2615
|
+
formatValue(inner, isStrict, isNormalized && getFunctionClass(value) !== "lambda");
|
|
2104
2616
|
if (functionValue.domain.every((key, index) => key === index + 1)) {
|
|
2105
|
-
return `<<${functionValue.range.map(
|
|
2617
|
+
return `<<${functionValue.range.map(formatRange).join(", ")}>>`;
|
|
2106
2618
|
}
|
|
2107
|
-
|
|
2619
|
+
// A RecordValue prints as a record whatever its fields, and a FcnRcdValue only if each key
|
|
2620
|
+
// is a name.
|
|
2621
|
+
if (
|
|
2622
|
+
getFunctionClass(value) === "record" ||
|
|
2623
|
+
functionValue.domain.every((key) => typeof key === "string" && isFieldName(key))
|
|
2624
|
+
) {
|
|
2108
2625
|
const isSorted =
|
|
2109
2626
|
isNormalized || functionValue.hash !== 0 || functionValue.fingerprint !== 0;
|
|
2110
2627
|
const pairs = isSorted
|
|
2111
2628
|
? functionValue.domain.map((key, index) => [key, functionValue.range[index]])
|
|
2112
2629
|
: getWrittenPairs(functionValue);
|
|
2113
|
-
return `[${pairs.map((pair) => `${String(pair[0])} |-> ${
|
|
2630
|
+
return `[${pairs.map((pair) => `${String(pair[0])} |-> ${formatRange(pair[1])}`).join(", ")}]`;
|
|
2114
2631
|
}
|
|
2115
|
-
return `(${functionValue.domain.map((key, index) => `${format(key)} :> ${
|
|
2632
|
+
return `(${functionValue.domain.map((key, index) => `${format(key)} :> ${formatRange(functionValue.range[index])}`).join(" @@ ")})`;
|
|
2116
2633
|
}
|
|
2117
2634
|
}
|
|
2118
2635
|
};
|
|
2636
|
+
|
|
2637
|
+
// TLC's TLCState.toString: a line per variable, as a conjunction when there are several.
|
|
2638
|
+
export const formatState = (state: Record<string, Value>) => {
|
|
2639
|
+
const entries = Object.entries(state);
|
|
2640
|
+
return entries
|
|
2641
|
+
.map(
|
|
2642
|
+
([name, value]) =>
|
|
2643
|
+
`${entries.length === 1 ? "" : "/\\ "}${name} = ${prettyPrint(formatValue(value))}\n`,
|
|
2644
|
+
)
|
|
2645
|
+
.join("");
|
|
2646
|
+
};
|