tla-ts 0.0.3-dev.6a30eee → 0.0.3-dev.6ac5593
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +5 -1
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +70 -22
- package/dist/index.d.ts +70 -22
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +2 -2
- package/dist/parallel.cjs +1 -1
- package/dist/parallel.js +2 -2
- package/dist/run-cli.cjs +20 -18
- package/dist/run-cli.js +22 -20
- package/dist/transfer.cjs +41 -15
- package/dist/transfer.js +41 -15
- package/package.json +1 -1
- package/src/ast.ts +121 -4
- package/src/builtins.ts +9 -3
- package/src/check.ts +480 -106
- package/src/cli-options.ts +11 -5
- package/src/codegen.ts +15 -22
- package/src/config.ts +224 -170
- package/src/dependencies.ts +2 -2
- package/src/environment.ts +410 -130
- package/src/errors.ts +104 -3
- package/src/evaluate.ts +402 -182
- package/src/exit-codes.ts +21 -14
- package/src/fingerprints.ts +2 -1
- package/src/instances.ts +17 -16
- package/src/levels.ts +185 -44
- package/src/live-check.ts +132 -70
- package/src/liveness.ts +118 -24
- package/src/parallel-worker.ts +2 -2
- package/src/parallel.ts +5 -2
- package/src/parser.ts +172 -53
- package/src/resolve.ts +1378 -420
- package/src/run-cli.ts +106 -18
- package/src/runtime.ts +2 -0
- package/src/sany-lexer.ts +615 -0
- package/src/sany-parse-error.ts +3143 -0
- package/src/spec-description.ts +19 -8
- package/src/standard-modules.ts +54 -45
- package/src/standard-ranges.ts +116 -0
- package/src/state-graph.ts +157 -0
- package/src/subexpressions.ts +231 -171
- package/src/substitution-levels.ts +38 -17
- package/src/successors.ts +177 -37
- package/src/symmetry.ts +109 -41
- package/src/tableau.ts +51 -24
- package/src/tlc-ext.ts +29 -12
- package/src/tlc-module.ts +14 -33
- package/src/tlc-modules.ts +4 -0
- package/src/tlc-order.ts +8 -4
- package/src/tlc-random.ts +9 -6
- package/src/tlc-summary.ts +20 -5
- package/src/value-sources.ts +29 -0
- package/src/values.ts +242 -61
package/src/evaluate.ts
CHANGED
|
@@ -1,23 +1,25 @@
|
|
|
1
|
-
import
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
1
|
+
import {
|
|
2
|
+
getChildren,
|
|
3
|
+
isLocallyResolved,
|
|
4
|
+
type Bound,
|
|
5
|
+
type BoundPattern,
|
|
6
|
+
type DecimalExpression,
|
|
7
|
+
type Definition,
|
|
8
|
+
type Expression,
|
|
9
|
+
type FunctionDefinition,
|
|
10
|
+
type NumberExpression,
|
|
11
|
+
type OperatorParam,
|
|
12
|
+
type RecordField,
|
|
12
13
|
} from "./ast";
|
|
13
14
|
import { getKindString } from "./builtins";
|
|
14
|
-
import { TlaEvaluationError } from "./errors";
|
|
15
|
-
import { EXIT_STATUS, setExitCode } from "./exit-codes";
|
|
15
|
+
import { formatRange, TlaEvaluationError, TlaUnassignedError } from "./errors";
|
|
16
|
+
import { EXIT_STATUS, setExitCode, setOwnExitCode } from "./exit-codes";
|
|
16
17
|
import { generateEvaluator } from "./codegen";
|
|
17
18
|
import type { CheckerRuntime } from "./runtime";
|
|
18
19
|
import { getReadVariables } from "./dependencies";
|
|
19
20
|
import { contextualApplications, mapChildren, substitutedExpressions } from "./instances";
|
|
20
|
-
import { isEnabled } from "./successors";
|
|
21
|
+
import { getReadLocals, isEnabled } from "./successors";
|
|
22
|
+
import { getFingerprintTrace, valueSources, withSource } from "./value-sources";
|
|
21
23
|
import {
|
|
22
24
|
applyFunction,
|
|
23
25
|
combineHash,
|
|
@@ -28,23 +30,28 @@ import {
|
|
|
28
30
|
createSortedSet,
|
|
29
31
|
createWrittenRecord,
|
|
30
32
|
createTuple,
|
|
33
|
+
describeMissingField,
|
|
31
34
|
formatValue,
|
|
32
35
|
getDomain,
|
|
33
36
|
getFunctionDomain,
|
|
34
37
|
getIntervalElements,
|
|
38
|
+
getLazySubsets,
|
|
35
39
|
getSequenceElements,
|
|
36
40
|
getValueHash,
|
|
37
|
-
isEnumerable,
|
|
38
41
|
isFunctionValue,
|
|
39
42
|
isOverriddenSet,
|
|
43
|
+
isRecordValue,
|
|
40
44
|
isSameValue,
|
|
41
45
|
markLambdaFunction,
|
|
46
|
+
isReducible,
|
|
42
47
|
isSetValue,
|
|
43
48
|
MAXIMUM_INTEGER,
|
|
44
49
|
MINIMUM_INTEGER,
|
|
45
50
|
toFiniteSet,
|
|
46
51
|
updateFunction,
|
|
47
52
|
valuesEqual,
|
|
53
|
+
type FilteredSetValue,
|
|
54
|
+
type FunctionValue,
|
|
48
55
|
type LazyFunctionSource,
|
|
49
56
|
type LazyFunctionValue,
|
|
50
57
|
type Value,
|
|
@@ -112,6 +119,7 @@ export interface Environment {
|
|
|
112
119
|
definitionValues: Map<Definition, Value>;
|
|
113
120
|
constantLevels: Map<Definition, boolean>;
|
|
114
121
|
evaluators: WeakMap<Expression, Evaluator>;
|
|
122
|
+
trace?: Expression[];
|
|
115
123
|
}
|
|
116
124
|
|
|
117
125
|
export interface Context {
|
|
@@ -141,9 +149,6 @@ const EXCEPT_AT = "@";
|
|
|
141
149
|
export const describeLocation = (expression: Expression) =>
|
|
142
150
|
`line ${expression.location.line}, column ${expression.location.column}`;
|
|
143
151
|
|
|
144
|
-
export const formatRange = (range: SourceRange) =>
|
|
145
|
-
`line ${range.start.line}, col ${range.start.column} to line ${range.end.line}, col ${range.end.column} of module ${range.module}`;
|
|
146
|
-
|
|
147
152
|
export const describeRange = (expression: Expression) => {
|
|
148
153
|
const range = expression.location.range;
|
|
149
154
|
return range ? formatRange(range) : describeLocation(expression);
|
|
@@ -180,8 +185,17 @@ export const getConjunctError = (
|
|
|
180
185
|
};
|
|
181
186
|
|
|
182
187
|
export const getFieldError =
|
|
183
|
-
(expression: Expression & { kind: "FieldAccess" }) => (record:
|
|
184
|
-
|
|
188
|
+
(expression: Expression & { kind: "FieldAccess" }) => (record: FunctionValue) =>
|
|
189
|
+
isRecordValue(record)
|
|
190
|
+
? `Attempted to select nonexistent field "${expression.field}" from the record\n${formatValue(record)}\n${describeRange(expression)}`
|
|
191
|
+
: describeMissingField(record, expression.field);
|
|
192
|
+
|
|
193
|
+
export const getNonFunctionError = (expression: Expression) => (value: Value) =>
|
|
194
|
+
`A non-function (${getKindString(value)}) was applied as a function.\n${describeRange(expression)}`;
|
|
195
|
+
|
|
196
|
+
export const getNonRecordError =
|
|
197
|
+
(expression: Expression & { kind: "FieldAccess" }) => (value: Value) =>
|
|
198
|
+
`Attempted to select field "${expression.field}" from a non-record value ${formatValue(value)}\n${describeRange(expression)}`;
|
|
185
199
|
|
|
186
200
|
export const getDomainOperator = (expression: Expression) => (value: Value) => {
|
|
187
201
|
if (!isFunctionValue(value)) {
|
|
@@ -262,96 +276,6 @@ export const expectBoolean = (value: Value, description: string) => {
|
|
|
262
276
|
return value;
|
|
263
277
|
};
|
|
264
278
|
|
|
265
|
-
export const getChildren = (expression: Expression): Expression[] => {
|
|
266
|
-
switch (expression.kind) {
|
|
267
|
-
case "Number":
|
|
268
|
-
case "Decimal":
|
|
269
|
-
case "String":
|
|
270
|
-
case "Identifier":
|
|
271
|
-
case "OperatorReference":
|
|
272
|
-
case "ExceptAt":
|
|
273
|
-
return [];
|
|
274
|
-
case "Apply":
|
|
275
|
-
return expression.args;
|
|
276
|
-
case "Lambda":
|
|
277
|
-
return [expression.body];
|
|
278
|
-
case "And":
|
|
279
|
-
case "Or":
|
|
280
|
-
return expression.operands;
|
|
281
|
-
case "Prime":
|
|
282
|
-
case "Unchanged":
|
|
283
|
-
case "Enabled":
|
|
284
|
-
case "Always":
|
|
285
|
-
case "Eventually":
|
|
286
|
-
return [expression.expression];
|
|
287
|
-
case "If":
|
|
288
|
-
return [expression.condition, expression.consequent, expression.alternative];
|
|
289
|
-
case "Case":
|
|
290
|
-
return [
|
|
291
|
-
...expression.arms.flatMap((arm) => [arm.condition, arm.body]),
|
|
292
|
-
...(expression.other ? [expression.other] : []),
|
|
293
|
-
];
|
|
294
|
-
case "Let":
|
|
295
|
-
return [
|
|
296
|
-
...expression.definitions.flatMap((definition) =>
|
|
297
|
-
definition.kind === "Function"
|
|
298
|
-
? [...definition.bounds.map((bound) => bound.set), definition.body]
|
|
299
|
-
: [definition.body],
|
|
300
|
-
),
|
|
301
|
-
expression.body,
|
|
302
|
-
];
|
|
303
|
-
case "Forall":
|
|
304
|
-
case "Exists":
|
|
305
|
-
return [...expression.bounds.map((bound) => bound.set), expression.body];
|
|
306
|
-
case "UnboundedQuantifier":
|
|
307
|
-
return [expression.body];
|
|
308
|
-
case "Choose":
|
|
309
|
-
return [...(expression.set ? [expression.set] : []), expression.body];
|
|
310
|
-
case "SetEnumeration":
|
|
311
|
-
case "Tuple":
|
|
312
|
-
return expression.elements;
|
|
313
|
-
case "SetFilter":
|
|
314
|
-
return [expression.bound.set, expression.predicate];
|
|
315
|
-
case "SetMap":
|
|
316
|
-
return [expression.expression, ...expression.bounds.map((bound) => bound.set)];
|
|
317
|
-
case "FunctionConstruction":
|
|
318
|
-
return [...expression.bounds.map((bound) => bound.set), expression.body];
|
|
319
|
-
case "FunctionSet":
|
|
320
|
-
return [expression.domain, expression.range];
|
|
321
|
-
case "Record":
|
|
322
|
-
case "RecordSet":
|
|
323
|
-
return expression.fields.map((field) => field.value);
|
|
324
|
-
case "Except":
|
|
325
|
-
return [
|
|
326
|
-
expression.function,
|
|
327
|
-
...expression.updates.flatMap((update) => [
|
|
328
|
-
...update.path.flatMap((step) => (step.kind === "Index" ? step.args : [])),
|
|
329
|
-
update.value,
|
|
330
|
-
]),
|
|
331
|
-
];
|
|
332
|
-
case "FunctionApplication":
|
|
333
|
-
return [expression.function, ...expression.args];
|
|
334
|
-
case "FieldAccess":
|
|
335
|
-
return [expression.record];
|
|
336
|
-
case "Product":
|
|
337
|
-
return expression.factors;
|
|
338
|
-
case "BoxAction":
|
|
339
|
-
case "AngleAction":
|
|
340
|
-
return [expression.action, expression.subscript];
|
|
341
|
-
case "WeakFairness":
|
|
342
|
-
case "StrongFairness":
|
|
343
|
-
return [expression.subscript, expression.action];
|
|
344
|
-
case "Label":
|
|
345
|
-
return [expression.body];
|
|
346
|
-
case "Subexpression":
|
|
347
|
-
return expression.selectors.flatMap((selector) => ("args" in selector ? selector.args : []));
|
|
348
|
-
}
|
|
349
|
-
};
|
|
350
|
-
|
|
351
|
-
export const isLocallyResolved = (expression: Expression) =>
|
|
352
|
-
(expression.kind === "Identifier" || expression.kind === "Apply") &&
|
|
353
|
-
expression.resolution?.kind === "Local";
|
|
354
|
-
|
|
355
279
|
export const getDefinition = (name: string, environment: Environment) =>
|
|
356
280
|
environment.definitions.get(environment.substitutions.get(name) ?? name);
|
|
357
281
|
|
|
@@ -419,9 +343,8 @@ export const getEnumeratedElements = (set: Value, expression: Expression) => {
|
|
|
419
343
|
: `TLC encountered the non-enumerable quantifier bound\n${text}\n${describeRange(expression)}\n${explanation}`,
|
|
420
344
|
);
|
|
421
345
|
}
|
|
422
|
-
|
|
423
|
-
|
|
424
|
-
: toFiniteSet(set).elements;
|
|
346
|
+
if (typeof set === "object" && set.kind === "Interval") return getIntervalElements(set);
|
|
347
|
+
return getLazySubsets(set) ?? toFiniteSet(set).elements;
|
|
425
348
|
};
|
|
426
349
|
|
|
427
350
|
export const forEachBinding = (
|
|
@@ -859,11 +782,7 @@ const evaluateLocalIdentifier = (name: string, expression: Expression, context:
|
|
|
859
782
|
const global = findGlobalName(name, context.environment);
|
|
860
783
|
if (global?.kind === "Variable") {
|
|
861
784
|
const value = context.state?.[global.index];
|
|
862
|
-
if (value === undefined)
|
|
863
|
-
throw new TlaEvaluationError(
|
|
864
|
-
`The variable ${name} is not assigned at ${describeLocation(expression)}`,
|
|
865
|
-
);
|
|
866
|
-
}
|
|
785
|
+
if (value === undefined) throw createUnassignedError(name, expression);
|
|
867
786
|
return value;
|
|
868
787
|
}
|
|
869
788
|
if (global?.kind === "Value") return global.value;
|
|
@@ -1103,23 +1022,88 @@ const isStateCached = (expression: Expression, environment: Environment) =>
|
|
|
1103
1022
|
getReadVariables(expression, environment) !== undefined &&
|
|
1104
1023
|
!hasFreeLocals(expression, NO_BOUND_NAMES);
|
|
1105
1024
|
|
|
1025
|
+
// CallStackTool also evaluates the predicate of a lazy set filter it returns, even one that TLC
|
|
1026
|
+
// made before the replay.
|
|
1027
|
+
const filteredSetRetracers = new WeakMap<
|
|
1028
|
+
FilteredSetValue,
|
|
1029
|
+
(environment: Environment) => FilteredSetValue
|
|
1030
|
+
>();
|
|
1031
|
+
|
|
1032
|
+
const SOURCED_KINDS = new Set<Expression["kind"]>([
|
|
1033
|
+
"SetEnumeration",
|
|
1034
|
+
"SetMap",
|
|
1035
|
+
"SetFilter",
|
|
1036
|
+
"Tuple",
|
|
1037
|
+
"Record",
|
|
1038
|
+
"RecordSet",
|
|
1039
|
+
"FunctionSet",
|
|
1040
|
+
"Product",
|
|
1041
|
+
]);
|
|
1042
|
+
|
|
1043
|
+
const SOURCED_OPERATORS = new Set(["SUBSET", "UNION", "DOMAIN", "\\cup", "\\cap", "\\"]);
|
|
1044
|
+
|
|
1045
|
+
// CallStackTool gives a set, tuple or record it builds the expression as its source, but not a lazy
|
|
1046
|
+
// set filter, which it returns as a copy.
|
|
1047
|
+
const isSourced = (expression: Expression, environment: Environment) =>
|
|
1048
|
+
SOURCED_KINDS.has(expression.kind) ||
|
|
1049
|
+
(expression.kind === "Apply" &&
|
|
1050
|
+
SOURCED_OPERATORS.has(expression.operator) &&
|
|
1051
|
+
!isLocallyResolved(expression) &&
|
|
1052
|
+
resolveGlobalOperator(expression.operator, environment)?.kind === "Builtin");
|
|
1053
|
+
|
|
1054
|
+
// When an evaluation fails, CallStackTool freezes the stack at the innermost expression and pushes
|
|
1055
|
+
// the source of each value whose method failed.
|
|
1056
|
+
const evaluateTraced = (
|
|
1057
|
+
evaluator: Evaluator,
|
|
1058
|
+
context: Context,
|
|
1059
|
+
trace: Expression[],
|
|
1060
|
+
depth: number,
|
|
1061
|
+
) => {
|
|
1062
|
+
try {
|
|
1063
|
+
return evaluator(context);
|
|
1064
|
+
} catch (error) {
|
|
1065
|
+
if (trace.length === depth + 1) trace.push(...(getFingerprintTrace(error) ?? []));
|
|
1066
|
+
throw error;
|
|
1067
|
+
}
|
|
1068
|
+
};
|
|
1069
|
+
|
|
1106
1070
|
export const getEvaluator = (expression: Expression, environment: Environment): Evaluator => {
|
|
1107
1071
|
const cached = environment.evaluators.get(expression);
|
|
1108
1072
|
if (cached) return cached;
|
|
1109
1073
|
const compiled = compile(expression, environment);
|
|
1110
|
-
const
|
|
1074
|
+
const cachedEvaluator =
|
|
1111
1075
|
isWorthCaching(expression) && isClosedConstant(expression, environment)
|
|
1112
1076
|
? cacheFirstValue(compiled)
|
|
1113
1077
|
: isStateCached(expression, environment)
|
|
1114
1078
|
? cacheStateValue(compiled)
|
|
1115
1079
|
: compiled;
|
|
1080
|
+
const trace = environment.trace;
|
|
1081
|
+
const isSourcedExpression = trace !== undefined && isSourced(expression, environment);
|
|
1082
|
+
// TLC's CallStackTool pushes each expression it evaluates and keeps the stack when one fails.
|
|
1083
|
+
const evaluator: Evaluator = trace
|
|
1084
|
+
? (context) => {
|
|
1085
|
+
const depth = trace.length;
|
|
1086
|
+
trace.push(expression);
|
|
1087
|
+
const value = evaluateTraced(cachedEvaluator, context, trace, depth);
|
|
1088
|
+
trace.length = depth;
|
|
1089
|
+
if (isSourcedExpression && typeof value === "object" && value.kind !== "FilteredSet") {
|
|
1090
|
+
valueSources.current?.set(value, expression);
|
|
1091
|
+
}
|
|
1092
|
+
const retrace =
|
|
1093
|
+
typeof value === "object" && value.kind === "FilteredSet"
|
|
1094
|
+
? filteredSetRetracers.get(value)
|
|
1095
|
+
: undefined;
|
|
1096
|
+
return retrace ? retrace(environment) : value;
|
|
1097
|
+
}
|
|
1098
|
+
: cachedEvaluator;
|
|
1116
1099
|
environment.evaluators.set(expression, evaluator);
|
|
1117
1100
|
return evaluator;
|
|
1118
1101
|
};
|
|
1119
1102
|
|
|
1120
1103
|
const entryEvaluators = new WeakMap<Expression, Evaluator>();
|
|
1121
1104
|
|
|
1122
|
-
const getEntryEvaluator = (expression: Expression, environment: Environment) => {
|
|
1105
|
+
export const getEntryEvaluator = (expression: Expression, environment: Environment) => {
|
|
1106
|
+
if (environment.trace) return getEvaluator(expression, environment);
|
|
1123
1107
|
const cached = entryEvaluators.get(expression);
|
|
1124
1108
|
if (cached) return cached;
|
|
1125
1109
|
const evaluator =
|
|
@@ -1143,11 +1127,7 @@ const compileIdentifier = (
|
|
|
1143
1127
|
const index = global.index;
|
|
1144
1128
|
return (context) => {
|
|
1145
1129
|
const value = context.state?.[index];
|
|
1146
|
-
if (value === undefined)
|
|
1147
|
-
throw new TlaEvaluationError(
|
|
1148
|
-
`The variable ${name} is not assigned at ${describeLocation(expression)}`,
|
|
1149
|
-
);
|
|
1150
|
-
}
|
|
1130
|
+
if (value === undefined) throw createUnassignedError(name, expression);
|
|
1151
1131
|
return value;
|
|
1152
1132
|
};
|
|
1153
1133
|
}
|
|
@@ -1232,11 +1212,32 @@ const getLazyArguments = (args: Expression[], context: Context): OperatorValue[]
|
|
|
1232
1212
|
expression: arg,
|
|
1233
1213
|
}));
|
|
1234
1214
|
|
|
1215
|
+
const RECEIVING_OPERATORS = new Set(["=", "#", "\\in", "\\notin", "\\cup", "\\cap", "\\"]);
|
|
1216
|
+
|
|
1217
|
+
// The argument whose method TLC calls to apply a built-in operator.
|
|
1218
|
+
const getReceiver = (name: string, left: Value, right: Value) =>
|
|
1219
|
+
name === "\\in" ||
|
|
1220
|
+
name === "\\notin" ||
|
|
1221
|
+
((name === "\\cup" || name === "\\cap") && !isReducible(left))
|
|
1222
|
+
? right
|
|
1223
|
+
: left;
|
|
1224
|
+
|
|
1235
1225
|
const compileBuiltinCall = (
|
|
1236
1226
|
builtin: Builtin,
|
|
1237
1227
|
args: Expression[],
|
|
1238
1228
|
environment: Environment,
|
|
1239
1229
|
): Evaluator => {
|
|
1230
|
+
if (environment.trace && RECEIVING_OPERATORS.has(builtin.name) && args.length === 2) {
|
|
1231
|
+
const evaluateLeft = getEvaluator(args[0], environment);
|
|
1232
|
+
const evaluateRight = getEvaluator(args[1], environment);
|
|
1233
|
+
return (context) => {
|
|
1234
|
+
const left = evaluateLeft(context);
|
|
1235
|
+
const right = evaluateRight(context);
|
|
1236
|
+
return withSource(getReceiver(builtin.name, left, right), () =>
|
|
1237
|
+
builtin.evaluate([left, right], context),
|
|
1238
|
+
);
|
|
1239
|
+
};
|
|
1240
|
+
}
|
|
1240
1241
|
if (builtin.isLazy) {
|
|
1241
1242
|
return (context) => builtin.evaluate(getLazyArguments(args, context), context);
|
|
1242
1243
|
}
|
|
@@ -1296,52 +1297,180 @@ export const compileArgumentScope = (
|
|
|
1296
1297
|
};
|
|
1297
1298
|
|
|
1298
1299
|
interface MemoizedCall {
|
|
1300
|
+
sources: (Expression | undefined)[];
|
|
1299
1301
|
args: Value[];
|
|
1300
1302
|
value: Value;
|
|
1301
1303
|
}
|
|
1302
1304
|
|
|
1303
1305
|
const MEMOIZED_CALL_LIMIT = 1 << 16;
|
|
1304
1306
|
|
|
1305
|
-
|
|
1307
|
+
// A call site that finds fewer than half its calls in a state's memo after this many new ones
|
|
1308
|
+
// stops paying for the lookups.
|
|
1309
|
+
const MEMOIZED_TRIAL_CALLS = 1 << 10;
|
|
1310
|
+
|
|
1311
|
+
interface CallMemo {
|
|
1312
|
+
calls: Map<number, MemoizedCall[]>;
|
|
1313
|
+
size: number;
|
|
1314
|
+
state: Context["state"];
|
|
1315
|
+
}
|
|
1316
|
+
|
|
1317
|
+
interface CallMemos {
|
|
1318
|
+
constant: CallMemo;
|
|
1319
|
+
state: CallMemo;
|
|
1320
|
+
}
|
|
1321
|
+
|
|
1322
|
+
const createCallMemo = (): CallMemo => ({ calls: new Map(), size: 0, state: undefined });
|
|
1306
1323
|
|
|
1307
|
-
const
|
|
1324
|
+
const callMemos = new WeakMap<Closure, CallMemos>();
|
|
1325
|
+
|
|
1326
|
+
const getCallMemos = (closure: Closure) => {
|
|
1308
1327
|
const cached = callMemos.get(closure);
|
|
1309
1328
|
if (cached) return cached;
|
|
1310
|
-
const
|
|
1311
|
-
callMemos.set(closure,
|
|
1312
|
-
return
|
|
1329
|
+
const memos = { constant: createCallMemo(), state: createCallMemo() };
|
|
1330
|
+
callMemos.set(closure, memos);
|
|
1331
|
+
return memos;
|
|
1313
1332
|
};
|
|
1314
1333
|
|
|
1315
|
-
const
|
|
1316
|
-
|
|
1317
|
-
|
|
1318
|
-
|
|
1319
|
-
|
|
1334
|
+
const readsExceptAt = (expression: Expression): boolean =>
|
|
1335
|
+
expression.kind === "ExceptAt" || getChildren(expression).some(readsExceptAt);
|
|
1336
|
+
|
|
1337
|
+
// The locals an argument expression reads, when the state and their values decide its value. An @
|
|
1338
|
+
// reads the value its EXCEPT binds.
|
|
1339
|
+
const argumentLocals = new WeakMap<Expression, string[] | false>();
|
|
1340
|
+
|
|
1341
|
+
const getArgumentLocals = (expression: Expression, environment: Environment) => {
|
|
1342
|
+
const cached = argumentLocals.get(expression);
|
|
1343
|
+
if (cached !== undefined) return cached;
|
|
1344
|
+
const locals =
|
|
1345
|
+
getReadVariables(expression, environment) !== undefined &&
|
|
1346
|
+
getReadLocals(expression, NO_BOUND_NAMES);
|
|
1347
|
+
const unique = locals && [
|
|
1348
|
+
...new Set(readsExceptAt(expression) ? [...locals, EXCEPT_AT] : locals),
|
|
1349
|
+
];
|
|
1350
|
+
argumentLocals.set(expression, unique ?? false);
|
|
1351
|
+
return unique ?? false;
|
|
1352
|
+
};
|
|
1353
|
+
|
|
1354
|
+
// Hashing a lazy set or function would enumerate it, which TLC does only when it has to.
|
|
1355
|
+
const isEagerValue = (value: Value) =>
|
|
1356
|
+
typeof value !== "object" ||
|
|
1357
|
+
value.kind === "ModelValue" ||
|
|
1358
|
+
value.kind === "Set" ||
|
|
1359
|
+
value.kind === "Function" ||
|
|
1360
|
+
value.kind === "Interval";
|
|
1361
|
+
|
|
1362
|
+
// The key of the call being looked up, copied into the memo only when the call is new. Counts
|
|
1363
|
+
// mark its ends, since shortening an array is slow.
|
|
1364
|
+
const callKey = {
|
|
1365
|
+
sources: [] as (Expression | undefined)[],
|
|
1366
|
+
sourceCount: 0,
|
|
1367
|
+
args: [] as Value[],
|
|
1368
|
+
argCount: 0,
|
|
1369
|
+
hash: 0,
|
|
1370
|
+
isStateKeyed: false,
|
|
1371
|
+
};
|
|
1372
|
+
|
|
1373
|
+
// A model value's rank tells it apart without hashing its name.
|
|
1374
|
+
const getKeyHash = (value: Value) =>
|
|
1375
|
+
typeof value === "object" && value.kind === "ModelValue" ? value.rank : getValueHash(value);
|
|
1376
|
+
|
|
1377
|
+
const pushKeyValue = (value: Value) => {
|
|
1378
|
+
if (!isEagerValue(value)) return false;
|
|
1379
|
+
callKey.sources[callKey.sourceCount++] = undefined;
|
|
1380
|
+
callKey.args[callKey.argCount++] = value;
|
|
1381
|
+
callKey.hash = combineHash(callKey.hash, getKeyHash(value));
|
|
1382
|
+
return true;
|
|
1383
|
+
};
|
|
1384
|
+
|
|
1385
|
+
// An argument TLC has not evaluated yet stands for its expression and the values of the locals it
|
|
1386
|
+
// reads, so a call keeps the laziness of its arguments.
|
|
1387
|
+
const pushKeyExpression = (
|
|
1388
|
+
expression: Expression,
|
|
1389
|
+
locals: string[] | false,
|
|
1390
|
+
scope: Scope | undefined,
|
|
1391
|
+
) => {
|
|
1392
|
+
if (!locals) return false;
|
|
1393
|
+
callKey.sources[callKey.sourceCount++] = expression;
|
|
1394
|
+
callKey.isStateKeyed = true;
|
|
1395
|
+
for (let index = 0; index < locals.length; index++) {
|
|
1396
|
+
const local = lookupScope(scope, locals[index]);
|
|
1397
|
+
if (local?.kind !== "Value" || !isEagerValue(local.value)) return false;
|
|
1398
|
+
callKey.args[callKey.argCount++] = local.value;
|
|
1399
|
+
callKey.hash = combineHash(callKey.hash, getKeyHash(local.value));
|
|
1320
1400
|
}
|
|
1321
|
-
return
|
|
1401
|
+
return true;
|
|
1322
1402
|
};
|
|
1323
1403
|
|
|
1324
|
-
|
|
1325
|
-
|
|
1404
|
+
// Each argument adds to the key what compileArgumentBinder would bind its parameter to.
|
|
1405
|
+
const compileArgumentKey = (
|
|
1406
|
+
argument: Expression,
|
|
1407
|
+
environment: Environment,
|
|
1408
|
+
): ((context: Context) => boolean) => {
|
|
1409
|
+
const isLiteral =
|
|
1410
|
+
argument.kind === "String" || (argument.kind === "Number" && isTlcInteger(argument.value));
|
|
1411
|
+
if (isLiteral) return () => pushKeyValue(argument.value);
|
|
1412
|
+
if (argument.kind === "Identifier") {
|
|
1413
|
+
const global = isLocallyResolved(argument)
|
|
1414
|
+
? undefined
|
|
1415
|
+
: findGlobalName(argument.name, environment);
|
|
1416
|
+
if (global?.kind === "Value") return () => pushKeyValue(global.value);
|
|
1417
|
+
if (global === undefined) {
|
|
1418
|
+
return (context) => {
|
|
1419
|
+
const binding = lookupScope(context.scope, argument.name);
|
|
1420
|
+
if (binding?.kind === "Value") return pushKeyValue(binding.value);
|
|
1421
|
+
if (binding?.kind !== "Thunk" || binding.state !== context.state) return false;
|
|
1422
|
+
return pushKeyExpression(
|
|
1423
|
+
binding.expression,
|
|
1424
|
+
getArgumentLocals(binding.expression, environment),
|
|
1425
|
+
binding.scope,
|
|
1426
|
+
);
|
|
1427
|
+
};
|
|
1428
|
+
}
|
|
1429
|
+
}
|
|
1430
|
+
const locals = getArgumentLocals(argument, environment);
|
|
1431
|
+
return (context) => pushKeyExpression(argument, locals, context.scope);
|
|
1432
|
+
};
|
|
1433
|
+
|
|
1434
|
+
const isKnownCall = (call: MemoizedCall) => {
|
|
1435
|
+
if (call.args.length !== callKey.argCount || call.sources.length !== callKey.sourceCount) {
|
|
1436
|
+
return false;
|
|
1437
|
+
}
|
|
1438
|
+
for (let index = 0; index < callKey.sourceCount; index++) {
|
|
1439
|
+
if (call.sources[index] !== callKey.sources[index]) return false;
|
|
1440
|
+
}
|
|
1441
|
+
for (let index = 0; index < callKey.argCount; index++) {
|
|
1442
|
+
if (!isSameValue(call.args[index], callKey.args[index])) return false;
|
|
1443
|
+
}
|
|
1444
|
+
return true;
|
|
1445
|
+
};
|
|
1446
|
+
|
|
1447
|
+
const findCall = (bucket: MemoizedCall[] | undefined) => {
|
|
1448
|
+
if (bucket === undefined) return undefined;
|
|
1449
|
+
for (let index = 0; index < bucket.length; index++) {
|
|
1450
|
+
if (isKnownCall(bucket[index])) return bucket[index];
|
|
1451
|
+
}
|
|
1452
|
+
return undefined;
|
|
1453
|
+
};
|
|
1326
1454
|
|
|
1327
|
-
//
|
|
1328
|
-
// so its calls
|
|
1329
|
-
const
|
|
1455
|
+
// An operator without side effects yields the same value for the same arguments, a state-level one
|
|
1456
|
+
// in the same state, so its calls share one result.
|
|
1457
|
+
const getMemoizedLevel = (expression: Expression & { kind: "Apply" }, environment: Environment) => {
|
|
1330
1458
|
const definition = getDefinition(expression.operator, environment);
|
|
1331
|
-
|
|
1459
|
+
const isMemoizable =
|
|
1332
1460
|
definition?.kind === "Operator" &&
|
|
1333
1461
|
definition.params.length > 0 &&
|
|
1334
1462
|
definition.params.every((param) => param.arity === 0) &&
|
|
1335
|
-
|
|
1336
|
-
|
|
1337
|
-
);
|
|
1463
|
+
!isImpureDefinition(definition, environment);
|
|
1464
|
+
if (!isMemoizable) return undefined;
|
|
1465
|
+
if (isConstantLevel(definition, environment)) return "constant";
|
|
1466
|
+
return isStatePure(definition, environment) ? "state" : undefined;
|
|
1338
1467
|
};
|
|
1339
1468
|
|
|
1340
1469
|
const compileClosureCall = (
|
|
1341
1470
|
closure: Closure,
|
|
1342
1471
|
args: Expression[],
|
|
1343
1472
|
environment: Environment,
|
|
1344
|
-
|
|
1473
|
+
memoizedLevel: "constant" | "state" | undefined,
|
|
1345
1474
|
): Evaluator => {
|
|
1346
1475
|
const bindArguments = compileArgumentScope(closure, args, environment);
|
|
1347
1476
|
const compiled = { body: undefined as Evaluator | undefined };
|
|
@@ -1349,22 +1478,47 @@ const compileClosureCall = (
|
|
|
1349
1478
|
compiled.body ??= getEntryEvaluator(closure.body, environment);
|
|
1350
1479
|
return compiled.body({ environment, scope, state: context.state, next: context.next });
|
|
1351
1480
|
};
|
|
1352
|
-
if (!
|
|
1353
|
-
|
|
1481
|
+
if (!memoizedLevel || args.length !== closure.params.length) {
|
|
1482
|
+
return (context) => evaluateBody(bindArguments(context), context);
|
|
1483
|
+
}
|
|
1484
|
+
const memos = getCallMemos(closure);
|
|
1485
|
+
const keys = args.map((arg) => compileArgumentKey(arg, environment));
|
|
1486
|
+
const usage = { hits: 0, misses: 0 };
|
|
1354
1487
|
return (context) => {
|
|
1355
|
-
|
|
1356
|
-
|
|
1357
|
-
|
|
1358
|
-
|
|
1359
|
-
for (
|
|
1488
|
+
callKey.sourceCount = 0;
|
|
1489
|
+
callKey.argCount = 0;
|
|
1490
|
+
callKey.hash = args.length;
|
|
1491
|
+
callKey.isStateKeyed = false;
|
|
1492
|
+
for (let index = 0; index < keys.length; index++) {
|
|
1493
|
+
if (!keys[index](context)) return evaluateBody(bindArguments(context), context);
|
|
1494
|
+
}
|
|
1495
|
+
const isStateKeyed = memoizedLevel === "state" || callKey.isStateKeyed;
|
|
1496
|
+
if (isStateKeyed && usage.misses > MEMOIZED_TRIAL_CALLS && usage.hits < usage.misses) {
|
|
1497
|
+
return evaluateBody(bindArguments(context), context);
|
|
1498
|
+
}
|
|
1499
|
+
const memo = isStateKeyed ? memos.state : memos.constant;
|
|
1500
|
+
if (isStateKeyed && memo.state !== context.state) {
|
|
1501
|
+
memo.state = context.state;
|
|
1502
|
+
memo.calls.clear();
|
|
1503
|
+
memo.size = 0;
|
|
1504
|
+
}
|
|
1505
|
+
// A small integer key keeps the Map from boxing it.
|
|
1506
|
+
const hash = callKey.hash & 0x3fffffff;
|
|
1360
1507
|
const bucket = memo.calls.get(hash);
|
|
1361
|
-
const known = bucket
|
|
1362
|
-
if (known)
|
|
1363
|
-
|
|
1508
|
+
const known = findCall(bucket);
|
|
1509
|
+
if (known) {
|
|
1510
|
+
if (isStateKeyed) usage.hits++;
|
|
1511
|
+
return known.value;
|
|
1512
|
+
}
|
|
1513
|
+
if (isStateKeyed) usage.misses++;
|
|
1514
|
+
const sources = callKey.sources.slice(0, callKey.sourceCount);
|
|
1515
|
+
const keyArgs = callKey.args.slice(0, callKey.argCount);
|
|
1516
|
+
const value = evaluateBody(bindArguments(context), context);
|
|
1364
1517
|
if (memo.size < MEMOIZED_CALL_LIMIT) {
|
|
1365
1518
|
memo.size++;
|
|
1366
|
-
|
|
1367
|
-
|
|
1519
|
+
const call = { sources, args: keyArgs, value };
|
|
1520
|
+
if (bucket) bucket.push(call);
|
|
1521
|
+
else memo.calls.set(hash, [call]);
|
|
1368
1522
|
}
|
|
1369
1523
|
return value;
|
|
1370
1524
|
};
|
|
@@ -1391,11 +1545,18 @@ const compileApply = (
|
|
|
1391
1545
|
? undefined
|
|
1392
1546
|
: resolveGlobalOperator(expression.operator, environment);
|
|
1393
1547
|
if (global?.kind === "Closure") {
|
|
1394
|
-
return compileClosureCall(global, args, environment,
|
|
1548
|
+
return compileClosureCall(global, args, environment, getMemoizedLevel(expression, environment));
|
|
1395
1549
|
}
|
|
1396
1550
|
if (global?.kind === "Builtin" && global.name === "DOMAIN") {
|
|
1397
1551
|
const operand = getEvaluator(args[0], environment);
|
|
1398
1552
|
const domain = getDomainOperator(expression);
|
|
1553
|
+
// TLC builds a new interval for the domain of a tuple, so the source it gives one stays its own.
|
|
1554
|
+
if (environment.trace) {
|
|
1555
|
+
return (context) => {
|
|
1556
|
+
const value = domain(operand(context));
|
|
1557
|
+
return typeof value === "object" && value.kind === "Interval" ? { ...value } : value;
|
|
1558
|
+
};
|
|
1559
|
+
}
|
|
1399
1560
|
return (context) => domain(operand(context));
|
|
1400
1561
|
}
|
|
1401
1562
|
// TLC sorts the value of a constant TLCEval argument only where no context binds a name.
|
|
@@ -1411,6 +1572,13 @@ const compileApply = (
|
|
|
1411
1572
|
const left = getEvaluator(args[0], environment);
|
|
1412
1573
|
const right = getEvaluator(args[1], environment);
|
|
1413
1574
|
const subset = getSubsetOperator(expression, global);
|
|
1575
|
+
if (environment.trace) {
|
|
1576
|
+
return (context) => {
|
|
1577
|
+
const subsetValue = left(context);
|
|
1578
|
+
const superset = right(context);
|
|
1579
|
+
return withSource(subsetValue, () => subset(subsetValue, superset));
|
|
1580
|
+
};
|
|
1581
|
+
}
|
|
1414
1582
|
return (context) => subset(left(context), right(context));
|
|
1415
1583
|
}
|
|
1416
1584
|
if (global?.kind === "Builtin") return compileBuiltinCall(global, args, environment);
|
|
@@ -1421,6 +1589,11 @@ const compileApply = (
|
|
|
1421
1589
|
if (definition?.kind === "Function") {
|
|
1422
1590
|
throw new TlaEvaluationError(`${expression.operator} is a function; apply it with brackets`);
|
|
1423
1591
|
}
|
|
1592
|
+
if (expression.operator === "\\cdot") {
|
|
1593
|
+
throw new TlaEvaluationError(
|
|
1594
|
+
"The current version of TLC does not support action composition. An incomplete implementation can be enabled via the tlc2.tool.impl.Tool.cdot=true java property.",
|
|
1595
|
+
);
|
|
1596
|
+
}
|
|
1424
1597
|
throw new TlaEvaluationError(
|
|
1425
1598
|
`Unknown operator ${expression.operator} at ${describeLocation(expression)}`,
|
|
1426
1599
|
);
|
|
@@ -1516,7 +1689,13 @@ const compileFunctionConstruction = (
|
|
|
1516
1689
|
const set = getEvaluator(bound.set, environment);
|
|
1517
1690
|
return (context) => {
|
|
1518
1691
|
const domain = isSingleName ? set(context) : getBoundsDomain(bounds, context);
|
|
1519
|
-
|
|
1692
|
+
// TLC builds the function only when it reduces every domain, and evaluates the body lazily
|
|
1693
|
+
// otherwise.
|
|
1694
|
+
const domains =
|
|
1695
|
+
typeof domain === "object" && domain.kind === "ProductSet" && bounds.length > 1
|
|
1696
|
+
? domain.factors
|
|
1697
|
+
: [domain];
|
|
1698
|
+
if (expression.isRecursive || isKeptLazy || !domains.every(isReducible)) {
|
|
1520
1699
|
const functionValue = createLazyFunction(
|
|
1521
1700
|
domain,
|
|
1522
1701
|
(argument) => body(withScope(context, bindArgument(bounds, context.scope, argument))),
|
|
@@ -1605,16 +1784,21 @@ const compileSetComprehension = (
|
|
|
1605
1784
|
const pattern = expression.bound.pattern;
|
|
1606
1785
|
return (context) => {
|
|
1607
1786
|
const base = set(context);
|
|
1608
|
-
const
|
|
1787
|
+
const getTest = (evaluatePredicate: Evaluator) => (element: Value) =>
|
|
1609
1788
|
expectBoolean(
|
|
1610
|
-
|
|
1789
|
+
evaluatePredicate(withScope(context, bindPattern(context.scope, pattern, element))),
|
|
1611
1790
|
"a set filter predicate",
|
|
1612
1791
|
);
|
|
1613
|
-
const
|
|
1614
|
-
|
|
1615
|
-
(base
|
|
1616
|
-
|
|
1617
|
-
|
|
1792
|
+
const test = getTest(predicate);
|
|
1793
|
+
if (!isReducible(base)) {
|
|
1794
|
+
if (isSetValue(base)) {
|
|
1795
|
+
const filtered: FilteredSetValue = { kind: "FilteredSet", base, test };
|
|
1796
|
+
filteredSetRetracers.set(filtered, (traced) => ({
|
|
1797
|
+
...filtered,
|
|
1798
|
+
test: getTest(getEvaluator(expression.predicate, traced)),
|
|
1799
|
+
}));
|
|
1800
|
+
return filtered;
|
|
1801
|
+
}
|
|
1618
1802
|
throw new TlaEvaluationError(
|
|
1619
1803
|
`TLC encountered a non-enumerable quantifier bound ${formatValue(base)} at ${describeLocation(expression.bound.set)}`,
|
|
1620
1804
|
);
|
|
@@ -1659,11 +1843,30 @@ const compileSetComprehension = (
|
|
|
1659
1843
|
};
|
|
1660
1844
|
};
|
|
1661
1845
|
|
|
1662
|
-
|
|
1663
|
-
|
|
1664
|
-
|
|
1665
|
-
|
|
1846
|
+
// TLC orders a record's fields by name.
|
|
1847
|
+
export const getSortedFields = (fields: RecordField[]) =>
|
|
1848
|
+
[...fields].sort((left, right) => compareValues(left.name, right.name));
|
|
1849
|
+
|
|
1850
|
+
export const hasDuplicateFields = (sortedFields: RecordField[]) =>
|
|
1851
|
+
sortedFields.some((field, index) => index > 0 && sortedFields[index - 1].name === field.name);
|
|
1852
|
+
|
|
1853
|
+
export const createUnassignedError = (name: string, expression: Expression) =>
|
|
1854
|
+
setOwnExitCode(
|
|
1855
|
+
new TlaUnassignedError(
|
|
1856
|
+
`In evaluation, the identifier ${name} is either undefined or not an operator.\n${describeRange(expression)}`,
|
|
1857
|
+
name,
|
|
1858
|
+
),
|
|
1859
|
+
EXIT_STATUS.configParseError,
|
|
1666
1860
|
);
|
|
1861
|
+
|
|
1862
|
+
export const createPrimeOutsideActionError = (expression: Expression) =>
|
|
1863
|
+
new TlaEvaluationError(
|
|
1864
|
+
`A primed expression appears outside an action at ${describeLocation(expression)}`,
|
|
1865
|
+
);
|
|
1866
|
+
|
|
1867
|
+
const compileRecord = (recordFields: RecordField[], environment: Environment): Evaluator => {
|
|
1868
|
+
const fields = getSortedFields(recordFields);
|
|
1869
|
+
const hasDuplicates = hasDuplicateFields(fields);
|
|
1667
1870
|
const values = fields.map((field) => getEvaluator(field.value, environment));
|
|
1668
1871
|
if (hasDuplicates) {
|
|
1669
1872
|
return (context) =>
|
|
@@ -1741,11 +1944,7 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
1741
1944
|
case "Prime": {
|
|
1742
1945
|
const inner = child(expression.expression);
|
|
1743
1946
|
return (context) => {
|
|
1744
|
-
if (!context.next)
|
|
1745
|
-
throw new TlaEvaluationError(
|
|
1746
|
-
`A primed expression appears outside an action at ${describeLocation(expression)}`,
|
|
1747
|
-
);
|
|
1748
|
-
}
|
|
1947
|
+
if (!context.next) throw createPrimeOutsideActionError(expression);
|
|
1749
1948
|
return inner({
|
|
1750
1949
|
environment: context.environment,
|
|
1751
1950
|
scope: context.scope,
|
|
@@ -1825,9 +2024,7 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
1825
2024
|
case "Record":
|
|
1826
2025
|
return compileRecord(expression.fields, environment);
|
|
1827
2026
|
case "RecordSet": {
|
|
1828
|
-
const fields =
|
|
1829
|
-
compareValues(left.name, right.name),
|
|
1830
|
-
);
|
|
2027
|
+
const fields = getSortedFields(expression.fields);
|
|
1831
2028
|
const names = fields.map((field) => field.name);
|
|
1832
2029
|
const sets = fields.map((field) => child(field.value));
|
|
1833
2030
|
return (context) => ({ kind: "RecordSet", names, sets: sets.map((set) => set(context)) });
|
|
@@ -1848,18 +2045,41 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
1848
2045
|
keepLazy(expression.function);
|
|
1849
2046
|
const evaluateFunction = child(expression.function);
|
|
1850
2047
|
const args = expression.args.map(child);
|
|
2048
|
+
const describeNonFunction = getNonFunctionError(expression);
|
|
2049
|
+
if (args.length === 1 && environment.trace) {
|
|
2050
|
+
const argument = args[0];
|
|
2051
|
+
return (context) => {
|
|
2052
|
+
const functionValue = evaluateFunction(context);
|
|
2053
|
+
const argumentValue = argument(context);
|
|
2054
|
+
const apply = () =>
|
|
2055
|
+
applyFunction(functionValue, argumentValue, undefined, describeNonFunction);
|
|
2056
|
+
return isFunctionValue(functionValue) ? withSource(functionValue, apply) : apply();
|
|
2057
|
+
};
|
|
2058
|
+
}
|
|
1851
2059
|
if (args.length === 1) {
|
|
1852
2060
|
const argument = args[0];
|
|
1853
|
-
return (context) =>
|
|
2061
|
+
return (context) =>
|
|
2062
|
+
applyFunction(
|
|
2063
|
+
evaluateFunction(context),
|
|
2064
|
+
argument(context),
|
|
2065
|
+
undefined,
|
|
2066
|
+
describeNonFunction,
|
|
2067
|
+
);
|
|
1854
2068
|
}
|
|
1855
2069
|
return (context) =>
|
|
1856
|
-
applyFunction(
|
|
2070
|
+
applyFunction(
|
|
2071
|
+
evaluateFunction(context),
|
|
2072
|
+
createTuple(args.map((arg) => arg(context))),
|
|
2073
|
+
undefined,
|
|
2074
|
+
describeNonFunction,
|
|
2075
|
+
);
|
|
1857
2076
|
}
|
|
1858
2077
|
case "FieldAccess": {
|
|
1859
2078
|
const record = child(expression.record);
|
|
1860
2079
|
const field = expression.field;
|
|
1861
2080
|
const describeMissing = getFieldError(expression);
|
|
1862
|
-
|
|
2081
|
+
const describeNonRecord = getNonRecordError(expression);
|
|
2082
|
+
return (context) => applyFunction(record(context), field, describeMissing, describeNonRecord);
|
|
1863
2083
|
}
|
|
1864
2084
|
case "Product": {
|
|
1865
2085
|
const factors = expression.factors.map(child);
|