tla-ts 0.0.3-dev.d9ff6f2 → 0.0.3-dev.e5b05b9
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +24 -0
- package/dist/index.d.ts +24 -0
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +2 -2
- package/dist/parallel.cjs +1 -1
- package/dist/parallel.js +2 -2
- package/dist/run-cli.cjs +14 -14
- package/dist/run-cli.js +22 -22
- package/dist/transfer.cjs +28 -19
- package/dist/transfer.js +28 -19
- package/package.json +1 -1
- package/src/ast.ts +28 -4
- package/src/builtins.ts +9 -3
- package/src/check.ts +115 -40
- package/src/environment.ts +219 -69
- package/src/errors.ts +47 -3
- package/src/evaluate.ts +95 -6
- package/src/fingerprints.ts +2 -1
- package/src/levels.ts +143 -30
- package/src/parser.ts +152 -45
- package/src/resolve.ts +1255 -443
- package/src/run-cli.ts +34 -11
- package/src/sany-lexer.ts +615 -0
- package/src/sany-parse-error.ts +3143 -0
- package/src/standard-modules.ts +52 -38
- package/src/standard-ranges.ts +116 -0
- package/src/subexpressions.ts +115 -150
- package/src/substitution-levels.ts +38 -17
- package/src/successors.ts +40 -14
- package/src/value-sources.ts +29 -0
- package/src/values.ts +119 -41
|
@@ -1,6 +1,8 @@
|
|
|
1
|
-
import type { Declaration, Definition, Expression, SourceLocation } from "./ast";
|
|
2
|
-
import {
|
|
1
|
+
import type { Declaration, Definition, Expression, SourceLocation, Theorem } from "./ast";
|
|
2
|
+
import { createSanyError, formatRange } from "./errors";
|
|
3
3
|
import {
|
|
4
|
+
ACTION_LEVEL,
|
|
5
|
+
analyzeAssumeProve,
|
|
4
6
|
createLevelAnalyzer,
|
|
5
7
|
getArgumentKey,
|
|
6
8
|
MAX_LEVEL,
|
|
@@ -24,6 +26,7 @@ interface ModuleContext {
|
|
|
24
26
|
variables: string[];
|
|
25
27
|
definitions: Definition[];
|
|
26
28
|
assumptions: Expression[];
|
|
29
|
+
theorems: Theorem[];
|
|
27
30
|
getDefinition: (name: string) => Definition | undefined;
|
|
28
31
|
}
|
|
29
32
|
|
|
@@ -46,10 +49,7 @@ interface Substituted {
|
|
|
46
49
|
const getMaxLevel = (operator: OperatorLevels, index: number) =>
|
|
47
50
|
operator.maxLevels[index] ?? MAX_LEVEL;
|
|
48
51
|
|
|
49
|
-
export const
|
|
50
|
-
checks: InstanceCheck[],
|
|
51
|
-
getModule: (name: string) => ModuleContext,
|
|
52
|
-
) => {
|
|
52
|
+
export const createInstanceChecker = (getModule: (name: string) => ModuleContext) => {
|
|
53
53
|
const analyzers = new Map<string, ReturnType<typeof createLevelAnalyzer>>();
|
|
54
54
|
const getAnalyzer = (name: string) => {
|
|
55
55
|
const cached = analyzers.get(name);
|
|
@@ -101,17 +101,38 @@ export const checkInstances = (
|
|
|
101
101
|
definition.formals.every((formal) => formal.name !== operator && formal.name !== param),
|
|
102
102
|
),
|
|
103
103
|
);
|
|
104
|
+
const addAssumedLevels = (data: ReturnType<typeof analyzeAssumeProve>) => {
|
|
105
|
+
addLevels(data, () => true);
|
|
106
|
+
module.constants.forEach((constant) => {
|
|
107
|
+
if (data.params.has(constant.name)) {
|
|
108
|
+
putConstraint(levels.constraints, constant.name, ACTION_LEVEL);
|
|
109
|
+
}
|
|
110
|
+
});
|
|
111
|
+
};
|
|
104
112
|
module.assumptions.forEach((assumption) =>
|
|
105
|
-
|
|
113
|
+
addAssumedLevels(analyzer.analyze(assumption, new Map())),
|
|
114
|
+
);
|
|
115
|
+
module.theorems.forEach((theorem) =>
|
|
116
|
+
theorem.statement.kind === "AssumeProve"
|
|
117
|
+
? addAssumedLevels(analyzeAssumeProve(theorem.statement, new Map(), analyzer))
|
|
118
|
+
: addLevels(analyzer.analyze(theorem.statement, new Map()), () => true),
|
|
106
119
|
);
|
|
107
120
|
moduleLevels.set(name, levels);
|
|
108
121
|
return levels;
|
|
109
122
|
};
|
|
110
123
|
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
const
|
|
124
|
+
return (check: InstanceCheck) => {
|
|
125
|
+
const errors = new Map<string, { location: string; message: string }>();
|
|
126
|
+
// SANY reports each error at the whole instance.
|
|
127
|
+
const location = formatRange(
|
|
128
|
+
check.location.range ?? {
|
|
129
|
+
module: check.instancer,
|
|
130
|
+
start: check.location,
|
|
131
|
+
end: check.location,
|
|
132
|
+
},
|
|
133
|
+
);
|
|
134
|
+
const addMessage = (message: string) =>
|
|
135
|
+
errors.set(`${location}\n${message}`, { location, message });
|
|
115
136
|
const instancee = getModule(check.module);
|
|
116
137
|
const levels = getModuleLevels(check.module);
|
|
117
138
|
const analyzer = getAnalyzer(check.instancer);
|
|
@@ -141,14 +162,14 @@ export const checkInstances = (
|
|
|
141
162
|
];
|
|
142
163
|
});
|
|
143
164
|
const getLevelMessage = (name: string, level: number) =>
|
|
144
|
-
`Level error in instantiating module '${check.module}'
|
|
165
|
+
`Level error in instantiating module '${check.module}':\nThe level of the expression or operator substituted for '${name}' \nmust be at most ${level}.`;
|
|
145
166
|
substituted.forEach((item) => {
|
|
146
167
|
if (!levels.isConstant && item.level > item.maximumLevel) {
|
|
147
168
|
addMessage(getLevelMessage(item.name, item.maximumLevel));
|
|
148
169
|
}
|
|
149
170
|
if (!item.isLeibniz) {
|
|
150
171
|
addMessage(
|
|
151
|
-
`Error in instantiating module '${check.module}'
|
|
172
|
+
`Error in instantiating module '${check.module}':\n A non-Leibniz operator substituted for '${item.name}'.`,
|
|
152
173
|
);
|
|
153
174
|
}
|
|
154
175
|
});
|
|
@@ -162,7 +183,7 @@ export const checkInstances = (
|
|
|
162
183
|
const minimum = levels.argConstraints.get(getArgumentKey(item.name, index));
|
|
163
184
|
if (minimum !== undefined && getMaxLevel(operator, index) < minimum) {
|
|
164
185
|
addMessage(
|
|
165
|
-
`Level error in instantiating module '${check.module}'
|
|
186
|
+
`Level error in instantiating module '${check.module}':\nThe level of the argument ${index + 1} of the operator ${operator.name} \nmust be at least ${minimum}.`,
|
|
166
187
|
);
|
|
167
188
|
}
|
|
168
189
|
});
|
|
@@ -175,10 +196,10 @@ export const checkInstances = (
|
|
|
175
196
|
const maximum = getMaxLevel(operator, parameter.index);
|
|
176
197
|
if (argument.level > maximum) {
|
|
177
198
|
addMessage(
|
|
178
|
-
`Level error when instantiating module '${check.module}'
|
|
199
|
+
`Level error when instantiating module '${check.module}':\nThe level of the argument ${parameter.index} of the operator ${parameter.operator}' \nmust be at most ${maximum}.`,
|
|
179
200
|
);
|
|
180
201
|
}
|
|
181
202
|
});
|
|
182
|
-
|
|
183
|
-
|
|
203
|
+
if (errors.size > 0) throw createSanyError([...errors.values()]);
|
|
204
|
+
};
|
|
184
205
|
};
|
package/src/successors.ts
CHANGED
|
@@ -7,7 +7,12 @@ import {
|
|
|
7
7
|
type QuantifierExpression,
|
|
8
8
|
} from "./ast";
|
|
9
9
|
import { getReadVariables } from "./dependencies";
|
|
10
|
-
import {
|
|
10
|
+
import {
|
|
11
|
+
TlaEvaluationError,
|
|
12
|
+
TlaIllegalStateError,
|
|
13
|
+
TlaIncompleteStateError,
|
|
14
|
+
TlaUnassignedError,
|
|
15
|
+
} from "./errors";
|
|
11
16
|
import { EXIT_STATUS, setExitCode } from "./exit-codes";
|
|
12
17
|
import {
|
|
13
18
|
describeLocation,
|
|
@@ -53,6 +58,7 @@ export interface Successor {
|
|
|
53
58
|
interface Run {
|
|
54
59
|
environment: Environment;
|
|
55
60
|
isInit: boolean;
|
|
61
|
+
isEnabled: boolean;
|
|
56
62
|
current: Value[] | undefined;
|
|
57
63
|
isStopped: boolean;
|
|
58
64
|
}
|
|
@@ -950,8 +956,17 @@ const compileAction = (
|
|
|
950
956
|
const unchanged = getUnchangedWrapper(expression.subscript);
|
|
951
957
|
return (run, scope, partial, action, isFixed, onComplete) =>
|
|
952
958
|
body(run, scope, partial, action, isFixed, (nextPartial, nextAction) => {
|
|
953
|
-
|
|
954
|
-
|
|
959
|
+
// ENABLED evaluates the subscript on the successor that the action specifies. TLC names
|
|
960
|
+
// a variable that the action leaves without a value.
|
|
961
|
+
try {
|
|
962
|
+
if (!holds(unchanged, getContext(run, scope, nextPartial)))
|
|
963
|
+
onComplete(nextPartial, nextAction);
|
|
964
|
+
} catch (error) {
|
|
965
|
+
if (!run.isEnabled || !(error instanceof TlaUnassignedError)) throw error;
|
|
966
|
+
throw new TlaEvaluationError(
|
|
967
|
+
`The action formula A appearing in a WF_v(A) or SF_v(A) operator does not specify the primed value of the variable ${error.variable} occurring in the state formula v.\n`,
|
|
968
|
+
);
|
|
969
|
+
}
|
|
955
970
|
});
|
|
956
971
|
}
|
|
957
972
|
case "BoxAction":
|
|
@@ -1028,7 +1043,13 @@ export const isEnabled = (expression: Expression, context: Context): boolean =>
|
|
|
1028
1043
|
);
|
|
1029
1044
|
}
|
|
1030
1045
|
const environment = context.environment;
|
|
1031
|
-
const run: Run = {
|
|
1046
|
+
const run: Run = {
|
|
1047
|
+
environment,
|
|
1048
|
+
isInit: false,
|
|
1049
|
+
isEnabled: true,
|
|
1050
|
+
current: state,
|
|
1051
|
+
isStopped: false,
|
|
1052
|
+
};
|
|
1032
1053
|
// TLC stops computing ENABLED at the first successor, so it skips the rest of the action.
|
|
1033
1054
|
getRunner(expression, environment, false)(
|
|
1034
1055
|
run,
|
|
@@ -1049,7 +1070,13 @@ export const forEachInitialState = (
|
|
|
1049
1070
|
onState: (state: Value[]) => boolean,
|
|
1050
1071
|
scope?: Scope,
|
|
1051
1072
|
) => {
|
|
1052
|
-
const run: Run = {
|
|
1073
|
+
const run: Run = {
|
|
1074
|
+
environment,
|
|
1075
|
+
isInit: true,
|
|
1076
|
+
isEnabled: false,
|
|
1077
|
+
current: undefined,
|
|
1078
|
+
isStopped: false,
|
|
1079
|
+
};
|
|
1053
1080
|
getRunner(expression, environment, true)(
|
|
1054
1081
|
run,
|
|
1055
1082
|
scope,
|
|
@@ -1059,14 +1086,7 @@ export const forEachInitialState = (
|
|
|
1059
1086
|
(partial) => {
|
|
1060
1087
|
if (run.isStopped) return;
|
|
1061
1088
|
if (!isComplete(partial)) {
|
|
1062
|
-
|
|
1063
|
-
// an evaluation failure.
|
|
1064
|
-
throw setExitCode(
|
|
1065
|
-
new TlaEvaluationError(
|
|
1066
|
-
`The initial predicate does not assign ${getMissingVariables(partial, environment).join(", ")}`,
|
|
1067
|
-
),
|
|
1068
|
-
EXIT_STATUS.error,
|
|
1069
|
-
);
|
|
1089
|
+
throw setExitCode(new TlaIllegalStateError(partial), EXIT_STATUS.error);
|
|
1070
1090
|
}
|
|
1071
1091
|
run.isStopped = onState(partial);
|
|
1072
1092
|
},
|
|
@@ -1098,7 +1118,13 @@ export const forEachSuccessor = (
|
|
|
1098
1118
|
onSuccessor: (successor: Successor) => boolean,
|
|
1099
1119
|
scope?: Scope,
|
|
1100
1120
|
) => {
|
|
1101
|
-
const run: Run = {
|
|
1121
|
+
const run: Run = {
|
|
1122
|
+
environment,
|
|
1123
|
+
isInit: false,
|
|
1124
|
+
isEnabled: false,
|
|
1125
|
+
current: state,
|
|
1126
|
+
isStopped: false,
|
|
1127
|
+
};
|
|
1102
1128
|
const counter = { successors: 0 };
|
|
1103
1129
|
getRunner(expression, environment, false)(
|
|
1104
1130
|
run,
|
|
@@ -0,0 +1,29 @@
|
|
|
1
|
+
import type { Expression } from "./ast";
|
|
2
|
+
import { TlaEvaluationError } from "./errors";
|
|
3
|
+
import type { Value } from "./values";
|
|
4
|
+
|
|
5
|
+
// While TLC replays a failure, it gives each set, tuple or record it builds the expression that
|
|
6
|
+
// built it. A method of such a value that fails prepends that expression to the error's trace, and
|
|
7
|
+
// TLC reports the error as one it was unable to fingerprint.
|
|
8
|
+
export const valueSources: { current: WeakMap<object, Expression> | undefined } = {
|
|
9
|
+
current: undefined,
|
|
10
|
+
};
|
|
11
|
+
|
|
12
|
+
const fingerprintTraces = new WeakMap<TlaEvaluationError, Expression[]>();
|
|
13
|
+
|
|
14
|
+
export const getFingerprintTrace = (error: unknown) =>
|
|
15
|
+
error instanceof TlaEvaluationError ? fingerprintTraces.get(error) : undefined;
|
|
16
|
+
|
|
17
|
+
export const withSource = <T>(value: Value, run: () => T): T => {
|
|
18
|
+
const sources = valueSources.current;
|
|
19
|
+
if (!sources || typeof value !== "object") return run();
|
|
20
|
+
try {
|
|
21
|
+
return run();
|
|
22
|
+
} catch (error) {
|
|
23
|
+
const source = sources.get(value);
|
|
24
|
+
if (source && error instanceof TlaEvaluationError) {
|
|
25
|
+
fingerprintTraces.set(error, [source, ...(fingerprintTraces.get(error) ?? [])]);
|
|
26
|
+
}
|
|
27
|
+
throw error;
|
|
28
|
+
}
|
|
29
|
+
};
|
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 { valueSources, withSource } from "./value-sources";
|
|
3
4
|
|
|
4
5
|
export interface ModelValue {
|
|
5
6
|
kind: "ModelValue";
|
|
@@ -733,16 +734,17 @@ const compareSetLikeTlc = (left: ObjectValue, right: Value): number => {
|
|
|
733
734
|
);
|
|
734
735
|
};
|
|
735
736
|
|
|
736
|
-
const compareLikeTlc = (left: Value, right: Value): number =>
|
|
737
|
-
|
|
738
|
-
if (typeof
|
|
739
|
-
|
|
740
|
-
|
|
741
|
-
|
|
742
|
-
|
|
743
|
-
|
|
744
|
-
|
|
745
|
-
|
|
737
|
+
const compareLikeTlc = (left: Value, right: Value): number =>
|
|
738
|
+
withSource(left, () => {
|
|
739
|
+
if (typeof left !== "object") {
|
|
740
|
+
if (typeof right === typeof left) return compareValues(left, right);
|
|
741
|
+
if (isModelValue(right)) return compareModelValueWith(right, left);
|
|
742
|
+
throw new TlaEvaluationError(describeScalarMismatch(left, right, false));
|
|
743
|
+
}
|
|
744
|
+
if (left.kind === "ModelValue") return compareModelValue(left, right);
|
|
745
|
+
if (isFunctionValue(left)) return compareFunctionLikeTlc(left, right);
|
|
746
|
+
return compareSetLikeTlc(left, right);
|
|
747
|
+
});
|
|
746
748
|
|
|
747
749
|
const equalsElementsLikeTlc = (left: Value[], right: Value[]) =>
|
|
748
750
|
left.every((element, index) => equalsLikeTlc(element, right[index]));
|
|
@@ -830,16 +832,17 @@ const equalsSetLikeTlc = (left: ObjectValue, right: Value): boolean => {
|
|
|
830
832
|
);
|
|
831
833
|
};
|
|
832
834
|
|
|
833
|
-
const equalsLikeTlc = (left: Value, right: Value): boolean =>
|
|
834
|
-
|
|
835
|
-
if (typeof
|
|
836
|
-
|
|
837
|
-
|
|
838
|
-
|
|
839
|
-
|
|
840
|
-
|
|
841
|
-
|
|
842
|
-
|
|
835
|
+
const equalsLikeTlc = (left: Value, right: Value): boolean =>
|
|
836
|
+
withSource(left, () => {
|
|
837
|
+
if (typeof left !== "object") {
|
|
838
|
+
if (typeof right === typeof left) return left === right;
|
|
839
|
+
if (isModelValue(right)) return equalsModelValueWith(right, left);
|
|
840
|
+
throw new TlaEvaluationError(describeScalarMismatch(left, right, true));
|
|
841
|
+
}
|
|
842
|
+
if (left.kind === "ModelValue") return equalsModelValue(left, right);
|
|
843
|
+
if (isFunctionValue(left)) return equalsFunctionLikeTlc(left, right);
|
|
844
|
+
return equalsSetLikeTlc(left, right);
|
|
845
|
+
});
|
|
843
846
|
|
|
844
847
|
// TLC's ValueVec.sort, which inserts each element into the sorted prefix by binary search.
|
|
845
848
|
const sortLikeTlc = (elements: Value[]) => {
|
|
@@ -1196,6 +1199,41 @@ const advanceCombination = (indices: number[], length: number) => {
|
|
|
1196
1199
|
return false;
|
|
1197
1200
|
};
|
|
1198
1201
|
|
|
1202
|
+
// TLC enumerates SUBSET S lazily, by size and then in the order of S, so a quantifier that finds
|
|
1203
|
+
// its witness early never builds the rest. For a power set too large to build, the elements are
|
|
1204
|
+
// computed in that order as a loop reads them.
|
|
1205
|
+
export const getLazySubsets = (value: Value): Value[] | undefined => {
|
|
1206
|
+
if (typeof value !== "object" || value.kind !== "Subset" || isOverriddenSet(value.base)) {
|
|
1207
|
+
return undefined;
|
|
1208
|
+
}
|
|
1209
|
+
const base = toFiniteSet(value.base).elements;
|
|
1210
|
+
if (base.length <= MAXIMUM_ENUMERATED_SUBSET_BASE) return undefined;
|
|
1211
|
+
const cursor = { index: -1, indices: [0] };
|
|
1212
|
+
const getSubset = (index: number) => {
|
|
1213
|
+
if (index <= cursor.index) cursor.index = -1;
|
|
1214
|
+
while (cursor.index < index) {
|
|
1215
|
+
if (cursor.index === -1) cursor.indices = [];
|
|
1216
|
+
else if (!advanceCombination(cursor.indices, base.length)) {
|
|
1217
|
+
cursor.indices = Array.from({ length: cursor.indices.length + 1 }, (_, item) => item);
|
|
1218
|
+
}
|
|
1219
|
+
cursor.index++;
|
|
1220
|
+
}
|
|
1221
|
+
return createSortedSet(cursor.indices.map((item) => base[item]));
|
|
1222
|
+
};
|
|
1223
|
+
const length = 2 ** base.length;
|
|
1224
|
+
const isIndex = (property: string | symbol) =>
|
|
1225
|
+
typeof property === "string" && /^\d+$/.test(property) && Number(property) < length;
|
|
1226
|
+
return new Proxy<Value[]>([], {
|
|
1227
|
+
get: (target, property, receiver) => {
|
|
1228
|
+
if (property === "length") return length;
|
|
1229
|
+
return isIndex(property)
|
|
1230
|
+
? getSubset(Number(property))
|
|
1231
|
+
: Reflect.get(target, property, receiver);
|
|
1232
|
+
},
|
|
1233
|
+
has: (target, property) => isIndex(property) || Reflect.has(target, property),
|
|
1234
|
+
});
|
|
1235
|
+
};
|
|
1236
|
+
|
|
1199
1237
|
const getSortedSubsets = (base: Value[]) => {
|
|
1200
1238
|
const subsets: Value[] = [];
|
|
1201
1239
|
for (let size = 0; size <= base.length; size++) {
|
|
@@ -1288,7 +1326,7 @@ const enumerateSet = (value: Value): Value[] => {
|
|
|
1288
1326
|
case "SetOperation": {
|
|
1289
1327
|
if (
|
|
1290
1328
|
value.operator === "\\cup" &&
|
|
1291
|
-
(
|
|
1329
|
+
(!isTlcEnumerable(value.left) || !isTlcEnumerable(value.right))
|
|
1292
1330
|
) {
|
|
1293
1331
|
throw new TlaEvaluationError(
|
|
1294
1332
|
`Attempted to enumerate S \\cup T when S:\n${formatValue(value.left)}\nand T:\n${formatValue(value.right)}\nare not both enumerable`,
|
|
@@ -1296,14 +1334,14 @@ const enumerateSet = (value: Value): Value[] => {
|
|
|
1296
1334
|
}
|
|
1297
1335
|
if (
|
|
1298
1336
|
value.operator === "\\cap" &&
|
|
1299
|
-
|
|
1300
|
-
|
|
1337
|
+
!isTlcEnumerable(value.left) &&
|
|
1338
|
+
!isTlcEnumerable(value.right)
|
|
1301
1339
|
) {
|
|
1302
1340
|
throw new TlaEvaluationError(
|
|
1303
1341
|
`Attempted to enumerate S \\cap T when neither S:\n${formatValue(value.left)}\nnor T:\n${formatValue(value.right)}\nis enumerable`,
|
|
1304
1342
|
);
|
|
1305
1343
|
}
|
|
1306
|
-
if (value.operator === "\\" &&
|
|
1344
|
+
if (value.operator === "\\" && !isTlcEnumerable(value.left)) {
|
|
1307
1345
|
throw new TlaEvaluationError(
|
|
1308
1346
|
`Attempted to enumerate S \\ T when S:\n${formatValue(value.left)}\nis not enumerable.`,
|
|
1309
1347
|
);
|
|
@@ -1338,7 +1376,10 @@ export const toFiniteSet = (value: Value): SetValue => {
|
|
|
1338
1376
|
const cached = typeof value === "object" ? finiteSets.get(value) : undefined;
|
|
1339
1377
|
if (cached) return cached;
|
|
1340
1378
|
const set =
|
|
1341
|
-
(typeof value === "object" ? comparedSets.get(value) : undefined) ??
|
|
1379
|
+
(typeof value === "object" ? comparedSets.get(value) : undefined) ??
|
|
1380
|
+
(valueSources.current
|
|
1381
|
+
? withSource(value, () => enumerateFiniteSet(value))
|
|
1382
|
+
: enumerateFiniteSet(value));
|
|
1342
1383
|
if (typeof value === "object") finiteSets.set(value, set);
|
|
1343
1384
|
return set;
|
|
1344
1385
|
};
|
|
@@ -1387,14 +1428,14 @@ export const getStreamedElements = (value: Value): Value[] => {
|
|
|
1387
1428
|
}
|
|
1388
1429
|
if (value.kind !== "SetOperation") return toFiniteSet(value).elements;
|
|
1389
1430
|
if (value.operator === "\\cup") {
|
|
1390
|
-
return
|
|
1431
|
+
return !isTlcEnumerable(value.left) || !isTlcEnumerable(value.right)
|
|
1391
1432
|
? toFiniteSet(value).elements
|
|
1392
1433
|
: [...getStreamedElements(value.left), ...getStreamedElements(value.right)];
|
|
1393
1434
|
}
|
|
1394
1435
|
const isLeftEnumerated = value.operator === "\\" || isEnumerable(value.left);
|
|
1395
1436
|
const enumerated = isLeftEnumerated ? value.left : value.right;
|
|
1396
1437
|
const other = isLeftEnumerated ? value.right : value.left;
|
|
1397
|
-
if (
|
|
1438
|
+
if (!isTlcEnumerable(enumerated)) return toFiniteSet(value).elements;
|
|
1398
1439
|
return getStreamedElements(enumerated).filter(
|
|
1399
1440
|
(element) => isElementOf(element, other) === (value.operator === "\\cap"),
|
|
1400
1441
|
);
|
|
@@ -1597,6 +1638,12 @@ const describeNonSetMembership = (element: Value, value: Value) => {
|
|
|
1597
1638
|
return `${prefix} function ${formatValue(value)}`;
|
|
1598
1639
|
};
|
|
1599
1640
|
|
|
1641
|
+
// TLC checks membership in a set that another set holds through the inner set's own method.
|
|
1642
|
+
const isElementOfSet = (element: Value, set: Value) =>
|
|
1643
|
+
valueSources.current
|
|
1644
|
+
? withSource(set, () => isElementOf(element, set))
|
|
1645
|
+
: isElementOf(element, set);
|
|
1646
|
+
|
|
1600
1647
|
export const isElementOf = (element: Value, set: Value): boolean => {
|
|
1601
1648
|
if (!isSetValue(set)) throw new TlaEvaluationError(describeNonSetMembership(element, set));
|
|
1602
1649
|
switch (set.kind) {
|
|
@@ -1605,10 +1652,10 @@ export const isElementOf = (element: Value, set: Value): boolean => {
|
|
|
1605
1652
|
return findIndex(set.elements, element) !== -1;
|
|
1606
1653
|
} catch (error) {
|
|
1607
1654
|
if (!(error instanceof TlaEvaluationError)) throw error;
|
|
1608
|
-
return isElementOfLikeTlc(element, set.elements);
|
|
1655
|
+
return withSource(set, () => isElementOfLikeTlc(element, set.elements));
|
|
1609
1656
|
}
|
|
1610
1657
|
case "MixedSet":
|
|
1611
|
-
return isElementOfLikeTlc(element, set.elements);
|
|
1658
|
+
return withSource(set, () => isElementOfLikeTlc(element, set.elements));
|
|
1612
1659
|
case "Interval":
|
|
1613
1660
|
if (typeof element === "number") return element >= set.low && element <= set.high;
|
|
1614
1661
|
if (set.low <= set.high && !isModelValue(element)) {
|
|
@@ -1630,8 +1677,12 @@ export const isElementOf = (element: Value, set: Value): boolean => {
|
|
|
1630
1677
|
return set.name !== "Nat" || (typeof element === "number" && element >= 0);
|
|
1631
1678
|
}
|
|
1632
1679
|
case "Subset":
|
|
1633
|
-
if (!
|
|
1634
|
-
|
|
1680
|
+
if (!isTlcEnumerable(element)) {
|
|
1681
|
+
throw new TlaEvaluationError(
|
|
1682
|
+
`Attempted to check if the non-enumerable value\n${prettyPrint(formatValue(element))}\nis element of\n${prettyPrint(formatValue(set))}`,
|
|
1683
|
+
);
|
|
1684
|
+
}
|
|
1685
|
+
return toFiniteSet(element).elements.every((item) => isElementOfSet(item, set.base));
|
|
1635
1686
|
case "FunctionSet": {
|
|
1636
1687
|
if (!isFunctionValue(element)) {
|
|
1637
1688
|
if (isModelValue(element)) return false;
|
|
@@ -1648,7 +1699,7 @@ export const isElementOf = (element: Value, set: Value): boolean => {
|
|
|
1648
1699
|
{ kind: "Interval", low, high: low + functionValue.domain.length - 1 },
|
|
1649
1700
|
set.domain,
|
|
1650
1701
|
);
|
|
1651
|
-
return isDomain && functionValue.range.every((item) =>
|
|
1702
|
+
return isDomain && functionValue.range.every((item) => isElementOfSet(item, set.range));
|
|
1652
1703
|
}
|
|
1653
1704
|
case "RecordSet": {
|
|
1654
1705
|
const functionValue = isFunctionValue(element) ? toFiniteFunction(element) : undefined;
|
|
@@ -1662,7 +1713,7 @@ export const isElementOf = (element: Value, set: Value): boolean => {
|
|
|
1662
1713
|
functionValue.domain.length === set.names.length &&
|
|
1663
1714
|
set.names.every((name, index) => {
|
|
1664
1715
|
const position = findIndex(functionValue.domain, name);
|
|
1665
|
-
return position !== -1 &&
|
|
1716
|
+
return position !== -1 && isElementOfSet(functionValue.range[position], set.sets[index]);
|
|
1666
1717
|
})
|
|
1667
1718
|
);
|
|
1668
1719
|
}
|
|
@@ -1679,24 +1730,24 @@ export const isElementOf = (element: Value, set: Value): boolean => {
|
|
|
1679
1730
|
}
|
|
1680
1731
|
return (
|
|
1681
1732
|
elements.length === set.factors.length &&
|
|
1682
|
-
elements.every((item, index) =>
|
|
1733
|
+
elements.every((item, index) => isElementOfSet(item, set.factors[index]))
|
|
1683
1734
|
);
|
|
1684
1735
|
}
|
|
1685
1736
|
case "FilteredSet":
|
|
1686
|
-
return
|
|
1737
|
+
return isElementOfSet(element, set.base) && set.test(element);
|
|
1687
1738
|
case "Union":
|
|
1688
1739
|
if (!isTlcEnumerable(set.base)) {
|
|
1689
1740
|
throw new TlaEvaluationError(
|
|
1690
1741
|
`Attempted to check if:\n ${formatValue(element)}\nis an element of the non-enumerable set:\n ${formatUnion(set)}`,
|
|
1691
1742
|
);
|
|
1692
1743
|
}
|
|
1693
|
-
return toFiniteSet(set.base).elements.some((inner) =>
|
|
1744
|
+
return toFiniteSet(set.base).elements.some((inner) => isElementOfSet(element, inner));
|
|
1694
1745
|
case "SetOperation":
|
|
1695
1746
|
if (set.operator === "\\cup")
|
|
1696
|
-
return
|
|
1747
|
+
return isElementOfSet(element, set.left) || isElementOfSet(element, set.right);
|
|
1697
1748
|
return (
|
|
1698
|
-
|
|
1699
|
-
|
|
1749
|
+
isElementOfSet(element, set.left) &&
|
|
1750
|
+
isElementOfSet(element, set.right) === (set.operator === "\\cap")
|
|
1700
1751
|
);
|
|
1701
1752
|
case "SequenceSet": {
|
|
1702
1753
|
const elements = getSequenceElements(element);
|
|
@@ -1943,10 +1994,15 @@ const getElementContribution = (element: Value) =>
|
|
|
1943
1994
|
const getEntryContribution = (key: Value, value: Value) =>
|
|
1944
1995
|
finalizeHash((Math.imul(getValueHash(key), 0x27d4eb2d) + getValueHash(value)) | 0);
|
|
1945
1996
|
|
|
1997
|
+
const unenumeratedSets = { isHashed: false };
|
|
1998
|
+
|
|
1946
1999
|
const computeValueHash = (value: ObjectValue) => {
|
|
1947
2000
|
if (value.kind === "ModelValue") return finalizeHash(combineHash(hashString(value.name), 0x6d));
|
|
1948
2001
|
if (isSetValue(value)) {
|
|
1949
|
-
if (!isEnumerable(value))
|
|
2002
|
+
if (!isEnumerable(value)) {
|
|
2003
|
+
unenumeratedSets.isHashed = true;
|
|
2004
|
+
return hashString(getValueKey(value));
|
|
2005
|
+
}
|
|
1950
2006
|
const elements = toFiniteSet(value).elements;
|
|
1951
2007
|
let hash = SET_HASH_SEED;
|
|
1952
2008
|
for (let index = 0; index < elements.length; index++) {
|
|
@@ -1978,6 +2034,25 @@ export const getValueHash = (value: Value): number => {
|
|
|
1978
2034
|
return hash;
|
|
1979
2035
|
};
|
|
1980
2036
|
|
|
2037
|
+
const fingerprintLikeTlc = (value: Value): void => {
|
|
2038
|
+
if (typeof value !== "object" || value.kind === "ModelValue") return;
|
|
2039
|
+
if (isOverriddenSet(value)) {
|
|
2040
|
+
throw new TlaEvaluationError(
|
|
2041
|
+
`TLC has found a state in which the value of a variable contains ${formatValue(value)}`,
|
|
2042
|
+
);
|
|
2043
|
+
}
|
|
2044
|
+
if (isSetValue(value)) return toFiniteSet(value).elements.forEach(fingerprintLikeTlc);
|
|
2045
|
+
const functionValue = toFiniteFunction(value);
|
|
2046
|
+
functionValue.domain.forEach(fingerprintLikeTlc);
|
|
2047
|
+
functionValue.range.forEach(fingerprintLikeTlc);
|
|
2048
|
+
};
|
|
2049
|
+
|
|
2050
|
+
// TLC enumerates every set in a state to fingerprint it, so it fails on a set it can't enumerate.
|
|
2051
|
+
// A state holds one only if hashing it met one, so states go unchecked until then.
|
|
2052
|
+
export const assertFingerprintable = (state: Value[]) => {
|
|
2053
|
+
if (unenumeratedSets.isHashed) state.forEach(fingerprintLikeTlc);
|
|
2054
|
+
};
|
|
2055
|
+
|
|
1981
2056
|
const valueFingerprints = new WeakMap<ObjectValue, number>();
|
|
1982
2057
|
|
|
1983
2058
|
const finalizeFingerprint = (hash: number) => {
|
|
@@ -2004,7 +2079,10 @@ const getEntryFingerprint = (key: Value, value: Value) =>
|
|
|
2004
2079
|
const computeValueFingerprint = (value: ObjectValue) => {
|
|
2005
2080
|
if (value.kind === "ModelValue") return finalizeFingerprint(fingerprintString(value.name) ^ 0x3c);
|
|
2006
2081
|
if (isSetValue(value)) {
|
|
2007
|
-
if (!isEnumerable(value))
|
|
2082
|
+
if (!isEnumerable(value)) {
|
|
2083
|
+
unenumeratedSets.isHashed = true;
|
|
2084
|
+
return fingerprintString(getValueKey(value));
|
|
2085
|
+
}
|
|
2008
2086
|
const elements = toFiniteSet(value).elements;
|
|
2009
2087
|
let fingerprint = 0x1b873593;
|
|
2010
2088
|
for (let index = 0; index < elements.length; index++) {
|