tla-ts 0.0.3-dev.d9ff6f2 → 0.0.3-dev.e8bef80
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/cli.cjs +1 -1
- package/dist/cli.js +1 -1
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +166 -40
- package/dist/index.d.ts +166 -40
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +2 -2
- package/dist/parallel.cjs +1 -1
- package/dist/parallel.js +2 -2
- package/dist/run-cli.cjs +1351 -22
- package/dist/run-cli.js +1351 -22
- package/dist/transfer.cjs +83 -34
- package/dist/transfer.js +83 -34
- package/package.json +5 -1
- package/src/ast.ts +55 -7
- 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 +1331 -367
- package/src/cli.ts +8 -1
- package/src/codegen.ts +68 -21
- package/src/config.ts +226 -207
- package/src/environment.ts +423 -127
- package/src/errors.ts +168 -9
- package/src/evaluate.ts +720 -177
- package/src/exit-codes.ts +6 -24
- package/src/index.ts +1 -0
- package/src/instances.ts +3 -1
- package/src/java-overrides.ts +104 -25
- package/src/levels.ts +149 -31
- package/src/lexer.ts +122 -29
- package/src/live-check.ts +204 -148
- package/src/liveness.ts +191 -122
- package/src/obligation-expression.ts +2 -2
- package/src/obligation-source.ts +2 -0
- package/src/parallel-worker.ts +6 -1
- package/src/parallel.ts +57 -6
- package/src/parser.ts +428 -141
- 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 +1436 -459
- package/src/run-cli.ts +1166 -181
- package/src/runtime.ts +16 -0
- package/src/sany-builtins.ts +147 -0
- package/src/sany-generator.ts +3128 -0
- package/src/sany-levels.ts +1208 -0
- package/src/sany-lexer.ts +545 -0
- package/src/sany-linter.ts +122 -0
- package/src/sany-modules.ts +1398 -0
- package/src/sany-nodes.ts +463 -0
- package/src/sany-parse-error.ts +2161 -0
- package/src/sany-report.ts +356 -0
- package/src/sany-selectors.ts +738 -0
- package/src/sany-source.ts +248 -0
- package/src/sany-xml.ts +1017 -0
- package/src/spec-description.ts +25 -5
- package/src/standard-modules.ts +203 -146
- package/src/standard-ranges.ts +116 -0
- package/src/state-graph.ts +29 -6
- package/src/subexpressions.ts +221 -161
- package/src/substitution-levels.ts +38 -17
- package/src/successors.ts +161 -167
- package/src/symmetry.ts +168 -50
- package/src/tableau.ts +3 -1
- package/src/tlc-ext.ts +13 -17
- package/src/tlc-messages.ts +329 -0
- package/src/tlc-module.ts +49 -21
- package/src/tlc-modules.ts +0 -4
- package/src/tlc-order.ts +55 -9
- package/src/tlc-random.ts +28 -3
- package/src/tlc-replay.ts +655 -0
- package/src/tlc-version.ts +18 -0
- package/src/transfer.ts +15 -3
- package/src/value-sources.ts +29 -0
- package/src/values.ts +680 -255
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,10 +147,9 @@ export const isSetValue = (value: Value) =>
|
|
|
137
147
|
value.kind !== "Function" &&
|
|
138
148
|
value.kind !== "LazyFunction";
|
|
139
149
|
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
export const isReducible = (value: Value): value is ReducibleSet =>
|
|
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 =>
|
|
144
153
|
typeof value === "object" &&
|
|
145
154
|
(value.kind === "Set" || value.kind === "MixedSet" || value.kind === "Interval");
|
|
146
155
|
|
|
@@ -182,7 +191,7 @@ export const getWrittenPairs = (functionValue: FunctionValue): [Value, Value][]
|
|
|
182
191
|
};
|
|
183
192
|
|
|
184
193
|
export const createWrittenRecord = (names: Value[], range: Value[], writtenNames: Value[]) =>
|
|
185
|
-
setWrittenOrder(
|
|
194
|
+
setWrittenOrder(createSortedRecord(names, range), writtenNames);
|
|
186
195
|
|
|
187
196
|
// TLC sorts a value it compares even with itself, and every value inside it, so a value it has
|
|
188
197
|
// hashed or fingerprinted is already sorted.
|
|
@@ -267,7 +276,10 @@ const checkModelValueTypes = (left: Value, right: Value, isEquality: boolean) =>
|
|
|
267
276
|
|
|
268
277
|
// TLC orders strings and model value names by when it first interned the text, so every
|
|
269
278
|
// check sets the order of its spec's strings before it builds any value.
|
|
270
|
-
const stringOrder
|
|
279
|
+
const stringOrder: { ranks: Record<string, number>; size: number } = {
|
|
280
|
+
ranks: Object.create(null),
|
|
281
|
+
size: 0,
|
|
282
|
+
};
|
|
271
283
|
|
|
272
284
|
export const setStringOrder = (texts: Iterable<string>) => {
|
|
273
285
|
stringOrder.ranks = Object.create(null);
|
|
@@ -276,6 +288,14 @@ export const setStringOrder = (texts: Iterable<string>) => {
|
|
|
276
288
|
for (const text of texts) rankString(text);
|
|
277
289
|
};
|
|
278
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
|
+
|
|
279
299
|
export const rankString = (text: string) => {
|
|
280
300
|
if (stringOrder.ranks[text] === undefined) stringOrder.ranks[text] = stringOrder.size++;
|
|
281
301
|
return text;
|
|
@@ -378,7 +398,7 @@ export const compareValues = (left: Value, right: Value): number => {
|
|
|
378
398
|
`Attempted to compare ${describeKind(left)} ${formatValue(left)} with ${describeKind(right)} ${formatValue(right)}`,
|
|
379
399
|
);
|
|
380
400
|
}
|
|
381
|
-
if (isLeftSet) return compareSets(toFiniteSet(left),
|
|
401
|
+
if (isLeftSet) return compareSets(toFiniteSet(left), toFiniteSet(right));
|
|
382
402
|
return compareFunctions(toFiniteFunction(left), toFiniteFunction(right));
|
|
383
403
|
}
|
|
384
404
|
if (typeof left === "number" && typeof right === "number") return left - right;
|
|
@@ -422,9 +442,85 @@ export const createSortedFunction = (domain: Value[], range: Value[]): FunctionV
|
|
|
422
442
|
hash: 0,
|
|
423
443
|
fingerprint: 0,
|
|
424
444
|
writtenKeys: undefined,
|
|
445
|
+
functionClass: undefined,
|
|
425
446
|
});
|
|
426
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
|
+
|
|
427
522
|
export const valuesEqual = (left: Value, right: Value): boolean => {
|
|
523
|
+
cacheSet(left);
|
|
428
524
|
if (left === right) {
|
|
429
525
|
if (writtenOrderUse.isUsed) forgetWrittenOrder(left);
|
|
430
526
|
return left !== ANY_SET || compareAny(left);
|
|
@@ -498,28 +594,36 @@ export const valuesEqual = (left: Value, right: Value): boolean => {
|
|
|
498
594
|
return compareValues(left, right) === 0;
|
|
499
595
|
};
|
|
500
596
|
|
|
501
|
-
|
|
502
|
-
|
|
503
|
-
|
|
504
|
-
|
|
505
|
-
|
|
506
|
-
|
|
507
|
-
|
|
508
|
-
|
|
509
|
-
|
|
510
|
-
|
|
511
|
-
(
|
|
512
|
-
|
|
513
|
-
|
|
514
|
-
|
|
515
|
-
|
|
516
|
-
(
|
|
517
|
-
|
|
518
|
-
|
|
519
|
-
|
|
520
|
-
|
|
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;
|
|
521
621
|
};
|
|
522
622
|
|
|
623
|
+
export const isSameValue = createSameValueCheck(false);
|
|
624
|
+
|
|
625
|
+
export const isInterchangeableValue = createSameValueCheck(true);
|
|
626
|
+
|
|
523
627
|
// The comparisons above fail with their own messages. These follow the compareTo and equals
|
|
524
628
|
// methods of TLC's Java value classes, which word a failure by the class of the left operand, so a
|
|
525
629
|
// failed comparison runs again through them to fail as TLC does.
|
|
@@ -675,7 +779,7 @@ const compareFunctionLikeTlc = (left: FunctionValue | LazyFunctionValue, right:
|
|
|
675
779
|
compareElementsLikeTlc(functionValue.range, tuple)
|
|
676
780
|
);
|
|
677
781
|
}
|
|
678
|
-
if (left
|
|
782
|
+
if (getFunctionClass(left) === "record") {
|
|
679
783
|
const record = toTlcRecord(right);
|
|
680
784
|
if (!record) {
|
|
681
785
|
if (isModelValue(right)) return compareModelValueWith(right, left);
|
|
@@ -793,7 +897,7 @@ const equalsFunctionLikeTlc = (left: FunctionValue | LazyFunctionValue, right: V
|
|
|
793
897
|
equalsElementsLikeTlc(functionValue.range, tuple)
|
|
794
898
|
);
|
|
795
899
|
}
|
|
796
|
-
if (left
|
|
900
|
+
if (getFunctionClass(left) === "record") {
|
|
797
901
|
const record = toTlcRecord(right);
|
|
798
902
|
if (!record) {
|
|
799
903
|
if (isModelValue(right)) return equalsModelValueWith(right, left);
|
|
@@ -845,42 +949,75 @@ const equalsLikeTlc = (left: Value, right: Value): boolean => {
|
|
|
845
949
|
const sortLikeTlc = (elements: Value[]) => {
|
|
846
950
|
const sorted: Value[] = [];
|
|
847
951
|
for (const element of elements) {
|
|
848
|
-
const
|
|
849
|
-
|
|
850
|
-
const middle = bounds.low + ((bounds.high - bounds.low) >> 1);
|
|
851
|
-
bounds.comparison = compareLikeTlc(element, sorted[middle]);
|
|
852
|
-
if (bounds.comparison === 0) break;
|
|
853
|
-
if (bounds.comparison < 0) bounds.high = middle;
|
|
854
|
-
else bounds.low = middle + 1;
|
|
855
|
-
}
|
|
856
|
-
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);
|
|
857
954
|
}
|
|
858
955
|
return sorted;
|
|
859
956
|
};
|
|
860
957
|
|
|
861
|
-
//
|
|
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.
|
|
862
984
|
const isElementOfLikeTlc = (element: Value, elements: Value[]) =>
|
|
863
|
-
elements.some((member) => equalsLikeTlc(member, element));
|
|
985
|
+
elements.some((member) => callTracedMethod(member, () => equalsLikeTlc(member, element)));
|
|
864
986
|
|
|
865
|
-
|
|
866
|
-
|
|
867
|
-
|
|
868
|
-
|
|
869
|
-
|
|
870
|
-
|
|
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);
|
|
871
1002
|
}
|
|
872
1003
|
};
|
|
873
1004
|
|
|
874
|
-
|
|
875
|
-
|
|
1005
|
+
export const isEqualLikeTlc = (left: Value, right: Value) =>
|
|
1006
|
+
computeLikeTlcOnFailure(
|
|
1007
|
+
() => valuesEqual(left, right),
|
|
1008
|
+
() => equalsLikeTlc(left, right),
|
|
1009
|
+
);
|
|
1010
|
+
|
|
876
1011
|
const isStrictlySorted = (elements: Value[]) => {
|
|
877
1012
|
for (let index = 1; index < elements.length; index++) {
|
|
878
|
-
if (compareValues(elements[index], elements[index
|
|
1013
|
+
if (compareValues(elements[index - 1], elements[index]) >= 0) return false;
|
|
879
1014
|
}
|
|
880
1015
|
return true;
|
|
881
1016
|
};
|
|
882
1017
|
|
|
883
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]);
|
|
884
1021
|
if (elements.length < 2 || isStrictlySorted(elements)) return createSortedSet(elements);
|
|
885
1022
|
const sorted = [...elements].sort(compareValues);
|
|
886
1023
|
const unique = [sorted[0]];
|
|
@@ -892,14 +1029,11 @@ export const createSet = (elements: Value[]): SetValue => {
|
|
|
892
1029
|
|
|
893
1030
|
// TLC builds a set enumeration without sorting it, so one whose elements it can't compare still
|
|
894
1031
|
// evaluates.
|
|
895
|
-
export const createEnumeratedSet = (elements: Value[]): SetValue | MixedSetValue =>
|
|
896
|
-
|
|
897
|
-
|
|
898
|
-
|
|
899
|
-
|
|
900
|
-
return { kind: "MixedSet", elements };
|
|
901
|
-
}
|
|
902
|
-
};
|
|
1032
|
+
export const createEnumeratedSet = (elements: Value[]): SetValue | MixedSetValue =>
|
|
1033
|
+
computeLikeTlcOnFailure<SetValue | MixedSetValue>(
|
|
1034
|
+
() => createSet(elements),
|
|
1035
|
+
() => ({ kind: "MixedSet", elements }),
|
|
1036
|
+
);
|
|
903
1037
|
|
|
904
1038
|
export const EMPTY_SET = createSortedSet([]);
|
|
905
1039
|
|
|
@@ -978,12 +1112,15 @@ export const unionSorted = (left: SetValue, right: SetValue): SetValue => {
|
|
|
978
1112
|
}
|
|
979
1113
|
if (added.length === 0) return left;
|
|
980
1114
|
const union = createSortedSet(merged);
|
|
981
|
-
if (left.hash !== 0) {
|
|
1115
|
+
if (left.hash !== 0 && left.hash !== UNFINGERPRINTABLE_HASH) {
|
|
982
1116
|
let hash = left.hash;
|
|
983
|
-
|
|
984
|
-
|
|
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;
|
|
985
1122
|
}
|
|
986
|
-
union.hash = hash;
|
|
1123
|
+
if (index === added.length) union.hash = hash;
|
|
987
1124
|
}
|
|
988
1125
|
if (left.fingerprint !== 0) {
|
|
989
1126
|
let fingerprint = left.fingerprint;
|
|
@@ -1068,12 +1205,13 @@ const getIntervalValue = (high: number): IntervalValue => {
|
|
|
1068
1205
|
};
|
|
1069
1206
|
|
|
1070
1207
|
export const createTuple = (elements: Value[]): FunctionValue =>
|
|
1071
|
-
createSortedFunction(getIntervalDomain(elements.length), elements);
|
|
1208
|
+
setFunctionClass(createSortedFunction(getIntervalDomain(elements.length), elements), "tuple");
|
|
1072
1209
|
|
|
1073
|
-
export const createRecord = (fields: [string, Value][]): FunctionValue =>
|
|
1210
|
+
export const createRecord = (fields: [string, Value][]): FunctionValue =>
|
|
1211
|
+
setFunctionClass(createFunction(fields), "record");
|
|
1074
1212
|
|
|
1075
1213
|
// TLC's Enumerable classes: every set except the ones it implements in Java.
|
|
1076
|
-
const isTlcEnumerable = (value: Value) => isSetValue(value) && !isOverriddenSet(value);
|
|
1214
|
+
export const isTlcEnumerable = (value: Value) => isSetValue(value) && !isOverriddenSet(value);
|
|
1077
1215
|
|
|
1078
1216
|
const formatUnion = (value: UnionValue, isStrict = false) =>
|
|
1079
1217
|
`UNION(${formatValue(value.base, isStrict)})`;
|
|
@@ -1196,6 +1334,41 @@ const advanceCombination = (indices: number[], length: number) => {
|
|
|
1196
1334
|
return false;
|
|
1197
1335
|
};
|
|
1198
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
|
+
|
|
1199
1372
|
const getSortedSubsets = (base: Value[]) => {
|
|
1200
1373
|
const subsets: Value[] = [];
|
|
1201
1374
|
for (let size = 0; size <= base.length; size++) {
|
|
@@ -1207,7 +1380,30 @@ const getSortedSubsets = (base: Value[]) => {
|
|
|
1207
1380
|
return subsets;
|
|
1208
1381
|
};
|
|
1209
1382
|
|
|
1210
|
-
|
|
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[] => {
|
|
1211
1407
|
if (typeof value !== "object")
|
|
1212
1408
|
throw new TlaEvaluationError(`Expected a set but found ${formatValue(value)}`);
|
|
1213
1409
|
switch (value.kind) {
|
|
@@ -1221,7 +1417,14 @@ const enumerateSet = (value: Value): Value[] => {
|
|
|
1221
1417
|
return elements;
|
|
1222
1418
|
}
|
|
1223
1419
|
case "Subset": {
|
|
1224
|
-
|
|
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)) {
|
|
1424
|
+
throw new TlaEvaluationError(
|
|
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))}`,
|
|
1426
|
+
);
|
|
1427
|
+
}
|
|
1225
1428
|
const base = toFiniteSet(value.base).elements;
|
|
1226
1429
|
if (base.length > MAXIMUM_ENUMERATED_SUBSET_BASE) {
|
|
1227
1430
|
throw new TlaEvaluationError(describeOverflow(value));
|
|
@@ -1229,51 +1432,48 @@ const enumerateSet = (value: Value): Value[] => {
|
|
|
1229
1432
|
return getSortedSubsets(base);
|
|
1230
1433
|
}
|
|
1231
1434
|
case "FunctionSet": {
|
|
1232
|
-
if (isEmptySet(value)) return [];
|
|
1435
|
+
if (!valueVersion.is174 && isEmptySet(value)) return [];
|
|
1233
1436
|
if (isOverriddenSet(value.domain)) {
|
|
1234
1437
|
throw new TlaEvaluationError(
|
|
1235
1438
|
`Attempted to enumerate a set of the form [D -> R],but the domain D:\n${formatValue(value.domain)}\ncannot be enumerated.`,
|
|
1236
1439
|
);
|
|
1237
1440
|
}
|
|
1238
1441
|
const domain = getFunctionDomain(value.domain);
|
|
1239
|
-
|
|
1442
|
+
// TLC 1.7.4 requires an enumerable range even of an empty domain.
|
|
1443
|
+
if ((domain.length > 0 || valueVersion.is174) && isOverriddenSet(value.range)) {
|
|
1240
1444
|
throw new TlaEvaluationError(
|
|
1241
1445
|
`Attempted to enumerate a set of the form [D -> R],but the range R:\n${formatValue(value.range)}\ncannot be enumerated.`,
|
|
1242
1446
|
);
|
|
1243
1447
|
}
|
|
1244
|
-
const range = domain.length === 0 ? [] :
|
|
1448
|
+
const range = domain.length === 0 ? [] : getElements(value.range);
|
|
1245
1449
|
return getCartesianProduct(domain.map(() => range)).map((combination): Value =>
|
|
1246
1450
|
createSortedFunction(domain, combination),
|
|
1247
1451
|
);
|
|
1248
1452
|
}
|
|
1249
1453
|
case "RecordSet": {
|
|
1250
|
-
if (isEmptySet(value)) return [];
|
|
1251
|
-
const fields =
|
|
1252
|
-
|
|
1253
|
-
|
|
1254
|
-
|
|
1255
|
-
)
|
|
1256
|
-
|
|
1257
|
-
return toFiniteSet(set).elements;
|
|
1258
|
-
});
|
|
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
|
+
);
|
|
1259
1461
|
return getCartesianProduct(fields).map((combination) =>
|
|
1260
1462
|
createRecord(value.names.map((name, index): [string, Value] => [name, combination[index]])),
|
|
1261
1463
|
);
|
|
1262
1464
|
}
|
|
1263
1465
|
case "ProductSet": {
|
|
1264
|
-
if (isEmptySet(value)) return [];
|
|
1265
|
-
const factors =
|
|
1266
|
-
|
|
1267
|
-
|
|
1268
|
-
|
|
1269
|
-
)
|
|
1270
|
-
|
|
1271
|
-
return toFiniteSet(factor).elements;
|
|
1272
|
-
});
|
|
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
|
+
);
|
|
1273
1473
|
return getCartesianProduct(factors).map(createTuple);
|
|
1274
1474
|
}
|
|
1275
1475
|
case "FilteredSet":
|
|
1276
|
-
if (isOverriddenSet(value.base)) {
|
|
1476
|
+
if (!isSetValue(value.base) || isOverriddenSet(value.base)) {
|
|
1277
1477
|
throw new TlaEvaluationError(
|
|
1278
1478
|
`Attempted to enumerate { x \\in S : p(x) } when S:\n${formatValue(value.base)}\nis not enumerable`,
|
|
1279
1479
|
);
|
|
@@ -1288,7 +1488,7 @@ const enumerateSet = (value: Value): Value[] => {
|
|
|
1288
1488
|
case "SetOperation": {
|
|
1289
1489
|
if (
|
|
1290
1490
|
value.operator === "\\cup" &&
|
|
1291
|
-
(
|
|
1491
|
+
(!isTlcEnumerable(value.left) || !isTlcEnumerable(value.right))
|
|
1292
1492
|
) {
|
|
1293
1493
|
throw new TlaEvaluationError(
|
|
1294
1494
|
`Attempted to enumerate S \\cup T when S:\n${formatValue(value.left)}\nand T:\n${formatValue(value.right)}\nare not both enumerable`,
|
|
@@ -1296,21 +1496,21 @@ const enumerateSet = (value: Value): Value[] => {
|
|
|
1296
1496
|
}
|
|
1297
1497
|
if (
|
|
1298
1498
|
value.operator === "\\cap" &&
|
|
1299
|
-
|
|
1300
|
-
|
|
1499
|
+
!isTlcEnumerable(value.left) &&
|
|
1500
|
+
!isTlcEnumerable(value.right)
|
|
1301
1501
|
) {
|
|
1302
1502
|
throw new TlaEvaluationError(
|
|
1303
1503
|
`Attempted to enumerate S \\cap T when neither S:\n${formatValue(value.left)}\nnor T:\n${formatValue(value.right)}\nis enumerable`,
|
|
1304
1504
|
);
|
|
1305
1505
|
}
|
|
1306
|
-
if (value.operator === "\\" &&
|
|
1506
|
+
if (value.operator === "\\" && !isTlcEnumerable(value.left)) {
|
|
1307
1507
|
throw new TlaEvaluationError(
|
|
1308
1508
|
`Attempted to enumerate S \\ T when S:\n${formatValue(value.left)}\nis not enumerable.`,
|
|
1309
1509
|
);
|
|
1310
1510
|
}
|
|
1311
1511
|
if (value.operator === "\\cup")
|
|
1312
1512
|
return unionSorted(toFiniteSet(value.left), toFiniteSet(value.right)).elements;
|
|
1313
|
-
const isLeftEnumerated = value.operator === "\\" ||
|
|
1513
|
+
const isLeftEnumerated = value.operator === "\\" || isTlcEnumerable(value.left);
|
|
1314
1514
|
const enumerated = isLeftEnumerated ? value.left : value.right;
|
|
1315
1515
|
const other = isLeftEnumerated ? value.right : value.left;
|
|
1316
1516
|
return toFiniteSet(enumerated).elements.filter(
|
|
@@ -1328,7 +1528,6 @@ const enumerateSet = (value: Value): Value[] => {
|
|
|
1328
1528
|
};
|
|
1329
1529
|
|
|
1330
1530
|
const finiteSets = new WeakMap<ObjectValue, SetValue>();
|
|
1331
|
-
const comparedSets = new WeakMap<ObjectValue, SetValue>();
|
|
1332
1531
|
|
|
1333
1532
|
export const toFiniteSet = (value: Value): SetValue => {
|
|
1334
1533
|
if (typeof value === "object" && value.kind === "Set") return value;
|
|
@@ -1337,14 +1536,10 @@ export const toFiniteSet = (value: Value): SetValue => {
|
|
|
1337
1536
|
}
|
|
1338
1537
|
const cached = typeof value === "object" ? finiteSets.get(value) : undefined;
|
|
1339
1538
|
if (cached) return cached;
|
|
1340
|
-
const
|
|
1341
|
-
|
|
1342
|
-
if (typeof value === "object") finiteSets.set(value, set);
|
|
1343
|
-
return set;
|
|
1344
|
-
};
|
|
1345
|
-
|
|
1346
|
-
const enumerateFiniteSet = (value: Value) => {
|
|
1539
|
+
const sets = setTrace.sets;
|
|
1540
|
+
sets?.push(value);
|
|
1347
1541
|
const elements = enumerateSet(value);
|
|
1542
|
+
sets?.pop();
|
|
1348
1543
|
const isSorted =
|
|
1349
1544
|
typeof value === "object" &&
|
|
1350
1545
|
(value.kind === "MixedSet" ||
|
|
@@ -1354,27 +1549,46 @@ const enumerateFiniteSet = (value: Value) => {
|
|
|
1354
1549
|
value.kind === "ProductSet" ||
|
|
1355
1550
|
value.kind === "FunctionSet" ||
|
|
1356
1551
|
value.kind === "Subset");
|
|
1357
|
-
|
|
1358
|
-
|
|
1359
|
-
|
|
1360
|
-
// TLC converts the set a comparison receives as its argument without caching it, so a lazy set
|
|
1361
|
-
// compared that way still streams the sets it combines.
|
|
1362
|
-
const toComparedSet = (value: Value) => {
|
|
1363
|
-
const isStreamed =
|
|
1364
|
-
typeof value === "object" &&
|
|
1365
|
-
(value.kind === "Union" || value.kind === "SetOperation" || value.kind === "FilteredSet");
|
|
1366
|
-
if (!isStreamed || finiteSets.has(value)) return toFiniteSet(value);
|
|
1367
|
-
const compared = comparedSets.get(value);
|
|
1368
|
-
if (compared) return compared;
|
|
1369
|
-
const set = enumerateFiniteSet(value);
|
|
1370
|
-
comparedSets.set(value, set);
|
|
1552
|
+
const set = isSorted ? createSortedSet(elements) : createSet(elements);
|
|
1553
|
+
if (typeof value === "object") finiteSets.set(value, set);
|
|
1371
1554
|
return set;
|
|
1372
1555
|
};
|
|
1373
1556
|
|
|
1374
1557
|
// TLC's Enumerator for a lazy set streams the sets it combines until the set caches its elements,
|
|
1375
1558
|
// so an element that two of them share comes up once for each.
|
|
1376
1559
|
export const getStreamedElements = (value: Value): Value[] => {
|
|
1377
|
-
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[] => {
|
|
1378
1592
|
// TLC streams the sets of a UNION it hasn't enumerated, so a set that appears twice there yields
|
|
1379
1593
|
// its elements twice.
|
|
1380
1594
|
if (value.kind === "Union") {
|
|
@@ -1385,16 +1599,18 @@ export const getStreamedElements = (value: Value): Value[] => {
|
|
|
1385
1599
|
if (value.kind === "FilteredSet" && !isOverriddenSet(value.base)) {
|
|
1386
1600
|
return getStreamedElements(value.base).filter(value.test);
|
|
1387
1601
|
}
|
|
1602
|
+
const components = getCombinedSets(value);
|
|
1603
|
+
if (components?.some(isStreamedApart)) return enumerateSet(value, getStreamedElements);
|
|
1388
1604
|
if (value.kind !== "SetOperation") return toFiniteSet(value).elements;
|
|
1389
1605
|
if (value.operator === "\\cup") {
|
|
1390
|
-
return
|
|
1606
|
+
return !isTlcEnumerable(value.left) || !isTlcEnumerable(value.right)
|
|
1391
1607
|
? toFiniteSet(value).elements
|
|
1392
1608
|
: [...getStreamedElements(value.left), ...getStreamedElements(value.right)];
|
|
1393
1609
|
}
|
|
1394
|
-
const isLeftEnumerated = value.operator === "\\" ||
|
|
1610
|
+
const isLeftEnumerated = value.operator === "\\" || isTlcEnumerable(value.left);
|
|
1395
1611
|
const enumerated = isLeftEnumerated ? value.left : value.right;
|
|
1396
1612
|
const other = isLeftEnumerated ? value.right : value.left;
|
|
1397
|
-
if (
|
|
1613
|
+
if (!isTlcEnumerable(enumerated)) return toFiniteSet(value).elements;
|
|
1398
1614
|
return getStreamedElements(enumerated).filter(
|
|
1399
1615
|
(element) => isElementOf(element, other) === (value.operator === "\\cap"),
|
|
1400
1616
|
);
|
|
@@ -1431,9 +1647,13 @@ export const isEmptySet = (value: Value): boolean => {
|
|
|
1431
1647
|
}
|
|
1432
1648
|
};
|
|
1433
1649
|
|
|
1434
|
-
const getProductCardinality = (
|
|
1650
|
+
const getProductCardinality = (
|
|
1651
|
+
sets: Value[],
|
|
1652
|
+
version: TlcVersion | undefined,
|
|
1653
|
+
describe: () => string,
|
|
1654
|
+
) =>
|
|
1435
1655
|
sets.reduce<number>((product, set) => {
|
|
1436
|
-
const size = product * getCardinality(set);
|
|
1656
|
+
const size = product * getCardinality(set, version);
|
|
1437
1657
|
if (size > MAXIMUM_INTEGER) throw new TlaEvaluationError(describe());
|
|
1438
1658
|
return size;
|
|
1439
1659
|
}, 1);
|
|
@@ -1441,9 +1661,25 @@ const getProductCardinality = (sets: Value[], describe: () => string) =>
|
|
|
1441
1661
|
const describeOverflow = (value: Value) =>
|
|
1442
1662
|
`Overflow when computing the number of elements in:\n${formatValue(value)}`;
|
|
1443
1663
|
|
|
1444
|
-
|
|
1445
|
-
|
|
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
|
+
}
|
|
1446
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);
|
|
1447
1683
|
case "Interval": {
|
|
1448
1684
|
const size = Math.max(0, value.high - value.low + 1);
|
|
1449
1685
|
if (size > MAXIMUM_INTEGER) {
|
|
@@ -1459,16 +1695,19 @@ export const getCardinality = (value: Value): number => {
|
|
|
1459
1695
|
`Attempted to compute the number of elements in the overridden value ${formatValue(value)}.`,
|
|
1460
1696
|
);
|
|
1461
1697
|
case "Subset": {
|
|
1462
|
-
const size = getCardinality(value.base);
|
|
1698
|
+
const size = getCardinality(value.base, version);
|
|
1463
1699
|
if (size >= 31) throw new TlaEvaluationError(describeOverflow(value));
|
|
1464
1700
|
return 2 ** size;
|
|
1465
1701
|
}
|
|
1466
1702
|
case "FunctionSet": {
|
|
1467
|
-
if (
|
|
1468
|
-
|
|
1469
|
-
|
|
1470
|
-
|
|
1471
|
-
|
|
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;
|
|
1472
1711
|
const size = { value: 1 };
|
|
1473
1712
|
for (let index = 0; index < domainSize; index++) {
|
|
1474
1713
|
size.value *= rangeSize;
|
|
@@ -1477,15 +1716,17 @@ export const getCardinality = (value: Value): number => {
|
|
|
1477
1716
|
return size.value;
|
|
1478
1717
|
}
|
|
1479
1718
|
case "RecordSet":
|
|
1480
|
-
if (isEmptySet(value)) return 0;
|
|
1481
|
-
return getProductCardinality(value.sets, () => describeOverflow(value));
|
|
1719
|
+
if (version !== "1.7.4" && isEmptySet(value)) return 0;
|
|
1720
|
+
return getProductCardinality(value.sets, version, () => describeOverflow(value));
|
|
1482
1721
|
case "ProductSet":
|
|
1483
|
-
if (isEmptySet(value)) return 0;
|
|
1722
|
+
if (version !== "1.7.4" && isEmptySet(value)) return 0;
|
|
1484
1723
|
return getProductCardinality(
|
|
1485
1724
|
value.factors,
|
|
1725
|
+
version,
|
|
1486
1726
|
() => `Overflow when computing the number of elements in ${formatValue(value)}`,
|
|
1487
1727
|
);
|
|
1488
1728
|
default:
|
|
1729
|
+
cacheSet(value);
|
|
1489
1730
|
return toFiniteSet(value).elements.length;
|
|
1490
1731
|
}
|
|
1491
1732
|
};
|
|
@@ -1560,11 +1801,11 @@ export const isFiniteSet = (value: Value): boolean => {
|
|
|
1560
1801
|
}
|
|
1561
1802
|
};
|
|
1562
1803
|
|
|
1563
|
-
const findIndex = (sortedValues: Value[], target: Value) => {
|
|
1804
|
+
const findIndex = (sortedValues: Value[], target: Value, compare = compareValues) => {
|
|
1564
1805
|
const bounds = { low: 0, high: sortedValues.length - 1 };
|
|
1565
1806
|
while (bounds.low <= bounds.high) {
|
|
1566
1807
|
const middle = (bounds.low + bounds.high) >> 1;
|
|
1567
|
-
const comparison =
|
|
1808
|
+
const comparison = compare(sortedValues[middle], target);
|
|
1568
1809
|
if (comparison === 0) return middle;
|
|
1569
1810
|
if (comparison < 0) bounds.low = middle + 1;
|
|
1570
1811
|
else bounds.high = middle - 1;
|
|
@@ -1580,33 +1821,78 @@ export const getSequenceElements = (value: Value): Value[] | undefined => {
|
|
|
1580
1821
|
: undefined;
|
|
1581
1822
|
};
|
|
1582
1823
|
|
|
1583
|
-
const describeMembership = (element: Value, set: Value) =>
|
|
1584
|
-
`Attempted to check if the value ${formatValue(element)} is an element of ${formatValue(set)}`;
|
|
1585
|
-
|
|
1586
1824
|
const describeNonSetMembership = (element: Value, value: Value) => {
|
|
1587
1825
|
const prefix = `Attempted to check if the value:\n${formatValue(element)}\nis an element of the`;
|
|
1588
1826
|
if (!isFunctionValue(value)) return `${prefix} ${describeKind(value)} ${formatValue(value)}`;
|
|
1589
|
-
const
|
|
1590
|
-
|
|
1591
|
-
if (domain.length > 0 && domain.every((key) => typeof key === "string")) {
|
|
1827
|
+
const functionClass = getFunctionClass(value);
|
|
1828
|
+
if (functionClass === "record") {
|
|
1592
1829
|
return `Attempted to check if element:\n${formatValue(element)}\nis in the record:\n${formatValue(value)}`;
|
|
1593
1830
|
}
|
|
1594
|
-
if (
|
|
1595
|
-
return "Attempted to check set membership in a tuple value.";
|
|
1596
|
-
}
|
|
1831
|
+
if (functionClass === "tuple") return "Attempted to check set membership in a tuple value.";
|
|
1597
1832
|
return `${prefix} function ${formatValue(value)}`;
|
|
1598
1833
|
};
|
|
1599
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
|
+
|
|
1600
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 => {
|
|
1601
1884
|
if (!isSetValue(set)) throw new TlaEvaluationError(describeNonSetMembership(element, set));
|
|
1602
1885
|
switch (set.kind) {
|
|
1603
1886
|
case "Set":
|
|
1604
|
-
|
|
1605
|
-
|
|
1606
|
-
|
|
1607
|
-
|
|
1608
|
-
|
|
1609
|
-
|
|
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
|
+
);
|
|
1610
1896
|
case "MixedSet":
|
|
1611
1897
|
return isElementOfLikeTlc(element, set.elements);
|
|
1612
1898
|
case "Interval":
|
|
@@ -1630,11 +1916,18 @@ export const isElementOf = (element: Value, set: Value): boolean => {
|
|
|
1630
1916
|
return set.name !== "Nat" || (typeof element === "number" && element >= 0);
|
|
1631
1917
|
}
|
|
1632
1918
|
case "Subset":
|
|
1633
|
-
|
|
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
|
+
}
|
|
1634
1926
|
return toFiniteSet(element).elements.every((item) => isElementOf(item, set.base));
|
|
1635
1927
|
case "FunctionSet": {
|
|
1636
1928
|
if (!isFunctionValue(element)) {
|
|
1637
1929
|
if (isModelValue(element)) return false;
|
|
1930
|
+
// SetOfFcnsValue.member prints the element without Values.ppr.
|
|
1638
1931
|
throw new TlaEvaluationError(
|
|
1639
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))}`,
|
|
1640
1933
|
);
|
|
@@ -1702,7 +1995,10 @@ export const isElementOf = (element: Value, set: Value): boolean => {
|
|
|
1702
1995
|
const elements = getSequenceElements(element);
|
|
1703
1996
|
if (elements === undefined) {
|
|
1704
1997
|
if (isModelValue(element)) return false;
|
|
1705
|
-
|
|
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
|
+
);
|
|
1706
2002
|
}
|
|
1707
2003
|
return elements.every((item) => isElementOf(item, set.base));
|
|
1708
2004
|
}
|
|
@@ -1735,77 +2031,58 @@ export const toFiniteFunction = (value: Value): FunctionValue => {
|
|
|
1735
2031
|
if (typeof value === "object" && value.kind === "LazyFunction") {
|
|
1736
2032
|
if (!isEnumerable(value.domain)) getCardinality(value.domain);
|
|
1737
2033
|
const domain = getFunctionDomain(value.domain);
|
|
1738
|
-
return
|
|
1739
|
-
|
|
1740
|
-
|
|
2034
|
+
return setFunctionClass(
|
|
2035
|
+
createSortedFunction(
|
|
2036
|
+
domain,
|
|
2037
|
+
domain.map((key) => value.apply(key)),
|
|
2038
|
+
),
|
|
2039
|
+
getFunctionClass(value),
|
|
1741
2040
|
);
|
|
1742
2041
|
}
|
|
1743
2042
|
throw new TlaEvaluationError(`Expected a function but found ${formatValue(value)}`);
|
|
1744
2043
|
};
|
|
1745
2044
|
|
|
1746
|
-
const
|
|
1747
|
-
|
|
1748
|
-
|
|
1749
|
-
|
|
2045
|
+
export const describeMissingArgument = (
|
|
2046
|
+
functionValue: Value,
|
|
2047
|
+
argument: Value,
|
|
2048
|
+
version?: TlcVersion,
|
|
1750
2049
|
) => {
|
|
1751
|
-
|
|
1752
|
-
|
|
1753
|
-
|
|
1754
|
-
|
|
1755
|
-
|
|
1756
|
-
|
|
1757
|
-
|
|
1758
|
-
|
|
1759
|
-
|
|
1760
|
-
|
|
1761
|
-
|
|
1762
|
-
|
|
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
|
+
}
|
|
1763
2077
|
};
|
|
1764
2078
|
|
|
1765
|
-
|
|
1766
|
-
|
|
1767
|
-
|
|
1768
|
-
const
|
|
1769
|
-
|
|
1770
|
-
|
|
1771
|
-
|
|
1772
|
-
functionValue: FunctionValue | LazyFunctionValue,
|
|
1773
|
-
argument: Value,
|
|
1774
|
-
) => {
|
|
1775
|
-
if (lambdaFunctions.has(functionValue) || functionValue.kind === "LazyFunction")
|
|
1776
|
-
return `In applying the function\n${prettyPrint(formatValue(functionValue))},\nthe first argument is:\n${prettyPrint(formatValue(argument))}\nwhich is not in its domain.\n`;
|
|
1777
|
-
const functionClass = getFunctionClass(functionValue);
|
|
1778
|
-
if (functionClass === "TupleValue")
|
|
1779
|
-
return typeof argument === "number"
|
|
1780
|
-
? `Attempted to access index ${argument} of tuple\n${prettyPrint(formatValue(functionValue))}\nwhich is out of bounds.`
|
|
1781
|
-
: `Attempted to access tuple at a non integral index: ${prettyPrint(formatValue(argument))}`;
|
|
1782
|
-
if (functionClass === "RecordValue")
|
|
1783
|
-
return typeof argument === "string"
|
|
1784
|
-
? `Attempted to access nonexistent field '${argument}' of record\n${prettyPrint(formatValue(functionValue))}`
|
|
1785
|
-
: `Attempted to access record by a non-string argument: ${prettyPrint(formatValue(argument))}`;
|
|
1786
|
-
return functionClass === "IntervalFcnRcdValue" && typeof argument !== "number"
|
|
1787
|
-
? describeNonIntegerArgument(argument)
|
|
1788
|
-
: describeNotInDomain(functionValue, argument);
|
|
1789
|
-
};
|
|
1790
|
-
|
|
1791
|
-
// TLC selects a field of a value that isn't a record from the function the value converts to,
|
|
1792
|
-
// which keeps a tuple's domain as an interval.
|
|
1793
|
-
export const describeMissingField = (functionValue: FunctionValue, field: string) =>
|
|
1794
|
-
getFunctionClass(functionValue) === "FcnRcdValue"
|
|
1795
|
-
? describeNotInDomain(functionValue, field)
|
|
1796
|
-
: describeNonIntegerArgument(field);
|
|
1797
|
-
|
|
1798
|
-
export const isRecordValue = (functionValue: FunctionValue) =>
|
|
1799
|
-
getFunctionClass(functionValue) === "RecordValue";
|
|
1800
|
-
|
|
1801
|
-
// TLC checks the type of an argument to a tuple or a record before it looks the argument up, so
|
|
1802
|
-
// it never compares the argument with a key of another type.
|
|
1803
|
-
const isForeignKey = (domain: Value[], argument: Value) => {
|
|
1804
|
-
const first = domain[0];
|
|
1805
|
-
return typeof first === "number"
|
|
1806
|
-
? typeof argument !== "number" &&
|
|
1807
|
-
(domain === intervalDomains[domain.length] || intervalArrays.has(domain))
|
|
1808
|
-
: typeof first === "string" && typeof argument !== "string";
|
|
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}.`;
|
|
1809
2086
|
};
|
|
1810
2087
|
|
|
1811
2088
|
const findKeyIndex = (domain: Value[], argument: Value) => {
|
|
@@ -1821,16 +2098,57 @@ const findKeyIndex = (domain: Value[], argument: Value) => {
|
|
|
1821
2098
|
return findIndex(domain, argument);
|
|
1822
2099
|
};
|
|
1823
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
|
+
|
|
1824
2143
|
export const applyFunction = (
|
|
1825
2144
|
functionValue: Value,
|
|
1826
2145
|
argument: Value,
|
|
1827
|
-
describeMissing?: (functionValue: FunctionValue) => string,
|
|
1828
|
-
describeNonFunction?: (value: Value) => string,
|
|
2146
|
+
describeMissing?: (functionValue: FunctionValue, argument: Value) => string,
|
|
1829
2147
|
): Value => {
|
|
1830
2148
|
if (typeof functionValue === "object" && functionValue.kind === "LazyFunction") {
|
|
1831
2149
|
if (!isElementOf(argument, functionValue.domain)) {
|
|
1832
2150
|
throw new TlaEvaluationError(
|
|
1833
|
-
|
|
2151
|
+
getFunctionClass(functionValue) === "lambda"
|
|
1834
2152
|
? describeMissingArgument(functionValue, argument)
|
|
1835
2153
|
: `Attempted to apply a function to ${formatValue(argument)}, which is not in its domain`,
|
|
1836
2154
|
);
|
|
@@ -1839,18 +2157,12 @@ export const applyFunction = (
|
|
|
1839
2157
|
}
|
|
1840
2158
|
if (typeof functionValue !== "object" || functionValue.kind !== "Function") {
|
|
1841
2159
|
throw new TlaEvaluationError(
|
|
1842
|
-
|
|
1843
|
-
`Attempted to apply ${formatValue(functionValue)}, which is not a function`,
|
|
1844
|
-
);
|
|
1845
|
-
}
|
|
1846
|
-
const position = isForeignKey(functionValue.domain, argument)
|
|
1847
|
-
? -1
|
|
1848
|
-
: findKeyIndex(functionValue.domain, argument);
|
|
1849
|
-
if (position === -1) {
|
|
1850
|
-
throw new TlaEvaluationError(
|
|
1851
|
-
describeMissing?.(functionValue) ?? describeMissingArgument(functionValue, argument),
|
|
2160
|
+
`Attempted to apply ${formatValue(functionValue)}, which is not a function`,
|
|
1852
2161
|
);
|
|
1853
2162
|
}
|
|
2163
|
+
const describe = describeMissing ?? describeMissingArgument;
|
|
2164
|
+
const position = findKeyIndexLikeTlc(functionValue, argument, describe);
|
|
2165
|
+
if (position === -1) throw new TlaEvaluationError(describe(functionValue, argument));
|
|
1854
2166
|
return functionValue.range[position];
|
|
1855
2167
|
};
|
|
1856
2168
|
|
|
@@ -1879,28 +2191,45 @@ export const updateFunction = (
|
|
|
1879
2191
|
if (isLazy) {
|
|
1880
2192
|
if (!isElementOf(argument, functionValue.domain)) return functionValue;
|
|
1881
2193
|
const updated = update(functionValue.apply(argument));
|
|
1882
|
-
return
|
|
1883
|
-
|
|
1884
|
-
|
|
1885
|
-
|
|
1886
|
-
|
|
1887
|
-
|
|
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
|
+
);
|
|
1888
2208
|
}
|
|
1889
2209
|
const finite = toFiniteFunction(functionValue);
|
|
1890
|
-
const position =
|
|
2210
|
+
const position = findKeyIndexLikeTlc(finite, argument, describeExceptKey);
|
|
1891
2211
|
if (position === -1) return finite;
|
|
1892
2212
|
const range = [...finite.range];
|
|
1893
2213
|
const previous = finite.range[position];
|
|
1894
2214
|
const next = update(previous);
|
|
1895
2215
|
range[position] = next;
|
|
1896
|
-
const updated =
|
|
2216
|
+
const updated = setFunctionClass(
|
|
2217
|
+
createSortedFunction(finite.domain, range),
|
|
2218
|
+
getFunctionClass(finite),
|
|
2219
|
+
);
|
|
1897
2220
|
updated.writtenKeys = finite.writtenKeys;
|
|
1898
|
-
if (finite.hash !== 0) {
|
|
1899
|
-
const
|
|
1900
|
-
|
|
1901
|
-
|
|
1902
|
-
|
|
1903
|
-
|
|
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
|
+
}
|
|
1904
2233
|
}
|
|
1905
2234
|
if (finite.fingerprint !== 0) {
|
|
1906
2235
|
const key = finite.domain[position];
|
|
@@ -1937,32 +2266,103 @@ const hashString = (value: string) => {
|
|
|
1937
2266
|
const SET_HASH_SEED = 0x73a5c3e1;
|
|
1938
2267
|
const FUNCTION_HASH_SEED = 0x66d1b4f7;
|
|
1939
2268
|
|
|
1940
|
-
const getElementContribution = (
|
|
1941
|
-
finalizeHash((
|
|
2269
|
+
const getElementContribution = (elementHash: number) =>
|
|
2270
|
+
finalizeHash((elementHash + 0x9e3779b9) | 0);
|
|
1942
2271
|
|
|
1943
|
-
const getEntryContribution = (
|
|
1944
|
-
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;
|
|
1945
2279
|
|
|
1946
2280
|
const computeValueHash = (value: ObjectValue) => {
|
|
1947
2281
|
if (value.kind === "ModelValue") return finalizeHash(combineHash(hashString(value.name), 0x6d));
|
|
1948
2282
|
if (isSetValue(value)) {
|
|
1949
|
-
if (!isEnumerable(value)) return
|
|
2283
|
+
if (!isEnumerable(value)) return UNFINGERPRINTABLE_HASH;
|
|
1950
2284
|
const elements = toFiniteSet(value).elements;
|
|
1951
2285
|
let hash = SET_HASH_SEED;
|
|
1952
2286
|
for (let index = 0; index < elements.length; index++) {
|
|
1953
|
-
|
|
2287
|
+
const elementHash = getValueHash(elements[index]);
|
|
2288
|
+
if (elementHash === UNFINGERPRINTABLE_HASH) return UNFINGERPRINTABLE_HASH;
|
|
2289
|
+
hash = (hash + getElementContribution(elementHash)) | 0;
|
|
1954
2290
|
}
|
|
1955
2291
|
return hash;
|
|
1956
2292
|
}
|
|
2293
|
+
if (value.kind === "LazyFunction" && !isEnumerable(value.domain)) return UNFINGERPRINTABLE_HASH;
|
|
1957
2294
|
const functionValue = toFiniteFunction(value);
|
|
1958
2295
|
let hash = FUNCTION_HASH_SEED;
|
|
1959
2296
|
for (let index = 0; index < functionValue.domain.length; index++) {
|
|
1960
|
-
|
|
1961
|
-
|
|
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;
|
|
1962
2303
|
}
|
|
1963
2304
|
return hash;
|
|
1964
2305
|
};
|
|
1965
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
|
+
|
|
1966
2366
|
export const getValueHash = (value: Value): number => {
|
|
1967
2367
|
if (typeof value === "number") return finalizeHash(value ^ 0x5bd1e995);
|
|
1968
2368
|
if (typeof value === "boolean") return value ? 0x2b7e1516 : 0x28aed2a6;
|
|
@@ -2137,7 +2537,9 @@ const formatLazySet = (value: LazySetValue, isStrict: boolean): string => {
|
|
|
2137
2537
|
case "SetOperation":
|
|
2138
2538
|
return `${format(value.left)} ${value.operator} ${format(value.right)}`;
|
|
2139
2539
|
case "FilteredSet":
|
|
2140
|
-
return
|
|
2540
|
+
return value.source
|
|
2541
|
+
? `{${value.source.names} \\in ${format(value.base)} : <expression ${value.source.predicate}> }`
|
|
2542
|
+
: `{x \\in ${format(value.base)} : ...}`;
|
|
2141
2543
|
case "Union":
|
|
2142
2544
|
return formatUnion(value, isStrict);
|
|
2143
2545
|
}
|
|
@@ -2150,6 +2552,17 @@ const isFieldName = (name: string) =>
|
|
|
2150
2552
|
/\p{L}/u.test(name) &&
|
|
2151
2553
|
(name.length < 4 || !/^[WS]F_/.test(name));
|
|
2152
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
|
+
|
|
2153
2566
|
export const formatValue = (value: Value, isStrict = false, isNormalized = false): string => {
|
|
2154
2567
|
const format = (inner: Value) => formatValue(inner, isStrict, isNormalized);
|
|
2155
2568
|
if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
|
|
@@ -2181,22 +2594,34 @@ export const formatValue = (value: Value, isStrict = false, isNormalized = false
|
|
|
2181
2594
|
return `Seq(${format(value.base)})`;
|
|
2182
2595
|
case "Function":
|
|
2183
2596
|
case "LazyFunction": {
|
|
2184
|
-
|
|
2185
|
-
|
|
2597
|
+
const functionValue = value.kind === "LazyFunction" ? toPrintedFunction(value) : value;
|
|
2598
|
+
if (functionValue === undefined) {
|
|
2599
|
+
const source = value.kind === "LazyFunction" ? value.source : undefined;
|
|
2186
2600
|
if (!source) return "<function>";
|
|
2187
2601
|
const parameters = source.parameters
|
|
2188
2602
|
.map((parameter) => `${parameter.name} \\in ${formatValue(parameter.domain)}`)
|
|
2189
2603
|
.join(", ");
|
|
2190
2604
|
return `[${parameters} |-> <expression ${source.body}>]`;
|
|
2191
2605
|
}
|
|
2192
|
-
|
|
2606
|
+
if (
|
|
2607
|
+
functionValue.domain.length === 0 &&
|
|
2608
|
+
valueVersion.is174 &&
|
|
2609
|
+
getFunctionClass(value) !== "tuple"
|
|
2610
|
+
) {
|
|
2611
|
+
return "<< >>";
|
|
2612
|
+
}
|
|
2193
2613
|
// TLC normalizes a lambda's domain to print it, but evaluates its body afterward.
|
|
2194
2614
|
const formatRange = (inner: Value) =>
|
|
2195
|
-
formatValue(inner, isStrict, isNormalized && value
|
|
2615
|
+
formatValue(inner, isStrict, isNormalized && getFunctionClass(value) !== "lambda");
|
|
2196
2616
|
if (functionValue.domain.every((key, index) => key === index + 1)) {
|
|
2197
2617
|
return `<<${functionValue.range.map(formatRange).join(", ")}>>`;
|
|
2198
2618
|
}
|
|
2199
|
-
|
|
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
|
+
) {
|
|
2200
2625
|
const isSorted =
|
|
2201
2626
|
isNormalized || functionValue.hash !== 0 || functionValue.fingerprint !== 0;
|
|
2202
2627
|
const pairs = isSorted
|