tla-ts 0.0.3-dev.a85c0bd → 0.0.3-dev.a91da46

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.
Files changed (81) hide show
  1. package/dist/cli.cjs +1 -1
  2. package/dist/cli.js +1 -1
  3. package/dist/index.cjs +1 -1
  4. package/dist/index.d.cts +167 -27
  5. package/dist/index.d.ts +167 -27
  6. package/dist/index.js +1 -1
  7. package/dist/parallel-worker.cjs +1 -1
  8. package/dist/parallel-worker.js +2 -2
  9. package/dist/parallel.cjs +1 -1
  10. package/dist/parallel.js +2 -2
  11. package/dist/run-cli.cjs +1351 -20
  12. package/dist/run-cli.js +1351 -20
  13. package/dist/transfer.cjs +83 -28
  14. package/dist/transfer.js +83 -28
  15. package/package.json +5 -1
  16. package/src/ast.ts +52 -6
  17. package/src/bags.ts +4 -7
  18. package/src/builtins.ts +29 -11
  19. package/src/bundled-modules.ts +3 -3
  20. package/src/canonical.ts +4 -3
  21. package/src/check.ts +1332 -262
  22. package/src/cli.ts +8 -1
  23. package/src/codegen.ts +68 -21
  24. package/src/config.ts +252 -179
  25. package/src/environment.ts +431 -120
  26. package/src/errors.ts +195 -7
  27. package/src/evaluate.ts +718 -146
  28. package/src/exit-codes.ts +6 -24
  29. package/src/index.ts +1 -0
  30. package/src/instances.ts +4 -2
  31. package/src/java-overrides.ts +104 -25
  32. package/src/levels.ts +183 -37
  33. package/src/lexer.ts +32 -4
  34. package/src/live-check.ts +204 -148
  35. package/src/liveness.ts +190 -117
  36. package/src/obligation-expression.ts +2 -2
  37. package/src/obligation-source.ts +2 -0
  38. package/src/parallel-worker.ts +6 -1
  39. package/src/parallel.ts +57 -6
  40. package/src/parser.ts +436 -128
  41. package/src/pcal-ast.ts +770 -0
  42. package/src/pcal-parse.ts +1523 -0
  43. package/src/pcal-tokenize.ts +516 -0
  44. package/src/pcal-translate.ts +1230 -0
  45. package/src/pcal-validate.ts +454 -0
  46. package/src/randomization.ts +24 -7
  47. package/src/resolve.ts +1364 -405
  48. package/src/run-cli.ts +1167 -155
  49. package/src/runtime.ts +16 -0
  50. package/src/sany-builtins.ts +147 -0
  51. package/src/sany-generator.ts +3112 -0
  52. package/src/sany-levels.ts +1208 -0
  53. package/src/sany-lexer.ts +545 -0
  54. package/src/sany-linter.ts +122 -0
  55. package/src/sany-modules.ts +1398 -0
  56. package/src/sany-nodes.ts +463 -0
  57. package/src/sany-parse-error.ts +2161 -0
  58. package/src/sany-report.ts +354 -0
  59. package/src/sany-selectors.ts +738 -0
  60. package/src/sany-source.ts +248 -0
  61. package/src/sany-xml.ts +1017 -0
  62. package/src/spec-description.ts +26 -7
  63. package/src/standard-modules.ts +203 -146
  64. package/src/standard-ranges.ts +116 -0
  65. package/src/state-graph.ts +29 -6
  66. package/src/subexpressions.ts +221 -161
  67. package/src/substitution-levels.ts +38 -17
  68. package/src/successors.ts +158 -120
  69. package/src/symmetry.ts +168 -50
  70. package/src/tableau.ts +3 -1
  71. package/src/tlc-ext.ts +13 -17
  72. package/src/tlc-messages.ts +329 -0
  73. package/src/tlc-module.ts +49 -21
  74. package/src/tlc-modules.ts +0 -4
  75. package/src/tlc-order.ts +55 -9
  76. package/src/tlc-random.ts +28 -3
  77. package/src/tlc-replay.ts +655 -0
  78. package/src/tlc-version.ts +18 -0
  79. package/src/transfer.ts +15 -3
  80. package/src/value-sources.ts +29 -0
  81. package/src/values.ts +683 -256
package/src/evaluate.ts CHANGED
@@ -13,47 +13,62 @@ import {
13
13
  type SourceRange,
14
14
  } from "./ast";
15
15
  import { getKindString } from "./builtins";
16
- import { TlaEvaluationError } from "./errors";
17
- import { EXIT_STATUS, setExitCode, setOwnExitCode } from "./exit-codes";
16
+ import { isStackOverflow, TlaEvaluationError, TlaUnassignedError } from "./errors";
17
+ import { EXIT_STATUS, setExitCode } from "./exit-codes";
18
18
  import { generateEvaluator } from "./codegen";
19
+ import { MESSAGE_CODE } from "./tlc-messages";
19
20
  import type { CheckerRuntime } from "./runtime";
20
21
  import { getReadVariables } from "./dependencies";
21
22
  import { contextualApplications, mapChildren, substitutedExpressions } from "./instances";
23
+ import { prettyPrint } from "./pretty-print";
22
24
  import { isEnabled } from "./successors";
23
25
  import {
24
26
  applyFunction,
27
+ describeMissingArgument,
25
28
  combineHash,
26
29
  compareValues,
27
30
  createFunction,
31
+ createNonIntegerKeyError,
32
+ createRecord,
28
33
  createEnumeratedSet,
29
34
  createSortedFunction,
35
+ createSortedRecord,
30
36
  createSortedSet,
31
37
  createWrittenRecord,
32
38
  createTuple,
33
- describeMissingField,
34
39
  formatValue,
40
+ getCardinality,
35
41
  getDomain,
36
42
  getFunctionDomain,
37
43
  getIntervalElements,
44
+ getLazySubsets,
45
+ getStreamedElements,
46
+ getFunctionClass,
38
47
  getSequenceElements,
39
48
  getValueHash,
49
+ isElementOf,
50
+ isEnumerable,
40
51
  isFunctionValue,
41
52
  isOverriddenSet,
42
- isRecordValue,
43
53
  isSameValue,
44
54
  markLambdaFunction,
45
- isReducible,
55
+ isReducibleSet,
46
56
  isSetValue,
47
57
  MAXIMUM_INTEGER,
48
58
  MINIMUM_INTEGER,
59
+ toFiniteFunction,
49
60
  toFiniteSet,
50
61
  updateFunction,
51
62
  valuesEqual,
52
- type FunctionValue,
63
+ type FilteredSetValue,
53
64
  type LazyFunctionSource,
54
65
  type LazyFunctionValue,
66
+ type ObjectValue,
55
67
  type Value,
68
+ markNormalized,
69
+ setTrace,
56
70
  } from "./values";
71
+ import type { TlcVersion } from "./tlc-version";
57
72
 
58
73
  export type State = (Value | undefined)[];
59
74
 
@@ -76,6 +91,8 @@ export interface Builtin {
76
91
  evaluateUnary: ((value: Value) => Value) | undefined;
77
92
  evaluateBinary: ((left: Value, right: Value) => Value) | undefined;
78
93
  isStateLevel?: boolean;
94
+ // Whether TLC takes an application for a constant one although its value depends on the state.
95
+ isLevelConstant?: boolean;
79
96
  isLazy?: boolean;
80
97
  }
81
98
 
@@ -112,18 +129,89 @@ export interface Environment {
112
129
  builtins: Map<string, Builtin>;
113
130
  constants: Map<string, Value>;
114
131
  substitutions: Map<string, string>;
132
+ // The name SANY gives each definition that a named instance such as `M == INSTANCE Module`
133
+ // copies, such as M!Op, by the key of the copy.
134
+ instanceNames: Map<string, string>;
115
135
  variables: string[];
116
136
  variableIndex: Map<string, number>;
117
137
  definitionValues: Map<Definition, Value>;
118
138
  constantLevels: Map<Definition, boolean>;
139
+ // The definitions an INSTANCE copies from a module that declares constants or variables. SANY
140
+ // wraps the body of each in its substitutions.
141
+ substitutedDefinitions: Set<Definition>;
119
142
  evaluators: WeakMap<Expression, Evaluator>;
143
+ // The expressions being evaluated, outermost first, when the environment replays an error to
144
+ // find where it occurred, as TLC's CallStackTool does.
145
+ callStack?: CallStack;
120
146
  }
121
147
 
148
+ export interface CallStack {
149
+ expressions: Expression[];
150
+ // TLC stops popping the stack once an evaluation fails, so it keeps where the failure occurred.
151
+ isFrozen: boolean;
152
+ // The expression that built each value of the replay that TLC's CallStackTool gives a source.
153
+ sources: WeakMap<ObjectValue, Expression>;
154
+ // The value each expression of the replay last evaluated to.
155
+ values: WeakMap<Expression, Value>;
156
+ // The expression each failure last left, which tells a failure of an operand from one of the
157
+ // method that computes the operator.
158
+ failures: WeakMap<Error, Expression>;
159
+ // The failure of a value with a source, which TLC raises as a FingerprintException.
160
+ fingerprint?: FingerprintFailure;
161
+ }
162
+
163
+ export interface FingerprintFailure {
164
+ // The sources of the values whose methods failed, outermost first.
165
+ sources: Expression[];
166
+ // The message of the error the innermost one raised.
167
+ reason: string;
168
+ }
169
+
170
+ // The operators of Tool#evalAppl whose value TLC's CallStackTool gives a source.
171
+ const SOURCED_OPERATORS = new Set(["SUBSET", "UNION", "DOMAIN", "\\cup", "\\cap", "\\"]);
172
+
173
+ // CallStackTool copies the SetPredValue, FcnLambdaValue and OpLambdaValue that an evaluation
174
+ // returns without their source, and a function TLC builds from a FcnLambdaValue has none.
175
+ const SOURCED_KINDS = new Set<Expression["kind"]>([
176
+ "SetEnumeration",
177
+ "SetFilter",
178
+ "SetMap",
179
+ "Tuple",
180
+ "FunctionSet",
181
+ "Record",
182
+ "RecordSet",
183
+ "Product",
184
+ ]);
185
+
186
+ const isSourced = (expression: Expression) =>
187
+ SOURCED_KINDS.has(expression.kind) ||
188
+ (expression.kind === "Apply" && SOURCED_OPERATORS.has(expression.operator));
189
+
190
+ // The argument whose method Tool#evalAppl calls to compute an operator, as with S.member(e) for
191
+ // e \in S, f.apply(e) for f[e] when f is a function, or S.diff(T) for S \ T when S is Reducible.
192
+ const getReceiver = (expression: Expression, values: CallStack["values"]) => {
193
+ if (expression.kind === "FunctionApplication" || expression.kind === "Except") {
194
+ return expression.function;
195
+ }
196
+ if (expression.kind !== "Apply" || expression.args.length !== 2) return undefined;
197
+ if (["\\subseteq", "=", "#", "\\"].includes(expression.operator)) return expression.args[0];
198
+ if (expression.operator === "\\cap" || expression.operator === "\\cup") {
199
+ const left = values.get(expression.args[0]);
200
+ return left !== undefined && isReducibleSet(left) ? expression.args[0] : expression.args[1];
201
+ }
202
+ return expression.operator === "\\in" || expression.operator === "\\notin"
203
+ ? expression.args[1]
204
+ : undefined;
205
+ };
206
+
122
207
  export interface Context {
123
208
  environment: Environment;
124
209
  scope: Scope | undefined;
125
210
  state: State | undefined;
126
211
  next: State | undefined;
212
+ // EvalControl.KeepLazy, which Tool#evalAppl sets to evaluate the function it applies and which
213
+ // the evaluation passes on, so that a function constructor within builds a FcnLambdaValue.
214
+ isKeepLazy?: boolean;
127
215
  }
128
216
 
129
217
  export type Evaluator = (context: Context) => Value;
@@ -154,14 +242,20 @@ export const describeRange = (expression: Expression) => {
154
242
  return range ? formatRange(range) : describeLocation(expression);
155
243
  };
156
244
 
245
+ // SANY prints a numeral as written and any other expression by its location.
246
+ export const describeNode = (expression: Expression) =>
247
+ expression.kind === "Number"
248
+ ? (expression.text ?? String(expression.value))
249
+ : describeRange(expression);
250
+
157
251
  export const getConditionError = (expression: Expression, value: Value) =>
158
252
  new TlaEvaluationError(
159
253
  `A non-boolean expression (${getKindString(value)}) was used as the condition of an IF.\n${describeRange(expression)}`,
160
254
  );
161
255
 
162
- // TLC parses an infix chain of /\ as nested binary conjunctions and a bulleted list as one
163
- // conjunction list, and it words the error differently for each.
164
- export const getConjunctError = (
256
+ // TLC parses an infix chain of /\ or \/ as nested binary junctions and a bulleted list as one
257
+ // junction list, and it words the error differently for each.
258
+ export const getJunctionError = (
165
259
  expression: Expression & { kind: "And" | "Or" },
166
260
  index: number,
167
261
  value: Value,
@@ -171,31 +265,48 @@ export const getConjunctError = (
171
265
  range?.start.line === expression.location.line &&
172
266
  range.start.column === expression.location.column;
173
267
  if (isBulleted || !range) {
174
- const operand = expression.operands[index];
175
- // SANY prints a numeral as its value instead of its location.
176
- const description = operand.kind === "Number" ? String(operand.value) : describeRange(operand);
177
268
  return new TlaEvaluationError(
178
- `A non-boolean expression (${getKindString(value)}) was used as a formula in a conjunction.\n${description}`,
269
+ `A non-boolean expression (${getKindString(value)}) was used as a formula in a ${expression.kind === "And" ? "conjunction" : "disjunction"}.\n${describeNode(expression.operands[index])}`,
179
270
  );
180
271
  }
181
- const end = expression.operands[Math.max(index, 1)].location.range?.end ?? range.end;
272
+ const end = expression.prefixEnds?.[Math.max(index, 1) - 1] ?? range.end;
182
273
  return new TlaEvaluationError(
183
- `Attempted to evaluate an expression of form P /\\ Q when ${index === 0 ? "P" : "Q"} was\n${getKindString(value)}.\n${describeRange({ ...expression, location: { ...expression.location, range: { ...range, end } } })}`,
274
+ `Attempted to evaluate an expression of form P ${expression.kind === "And" ? "/\\" : "\\/"} Q when ${index === 0 ? "P" : "Q"} was\n${getKindString(value)}.\n${describeRange({ ...expression, location: { ...expression.location, range: { ...range, end } } })}`,
184
275
  );
185
276
  };
186
277
 
187
- export const getFieldError =
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)}`;
278
+ // TLC selects a field of a record, and of another function from the function it converts it to,
279
+ // which for a tuple keeps its domain as an interval.
280
+ export const getFieldSelector = (expression: Expression & { kind: "FieldAccess" }) => {
281
+ const field = expression.field;
282
+ const describeMissing = (record: Value) =>
283
+ `Attempted to select nonexistent field "${field}" from the record\n${formatValue(record)}\n${describeRange(expression)}`;
284
+ const describeNotInDomain = (functionValue: Value) =>
285
+ `Attempted to apply function:\n${prettyPrint(formatValue(functionValue))}\nto argument "${field}", which is not in the domain of the function.`;
286
+ return (value: Value) => {
287
+ if (!isFunctionValue(value)) {
288
+ throw new TlaEvaluationError(
289
+ `Attempted to select field "${field}" from a non-record value ${prettyPrint(formatValue(value))}\n${describeRange(expression)}`,
290
+ );
291
+ }
292
+ const functionClass = getFunctionClass(value);
293
+ if (functionClass === "tuple") throw createNonIntegerKeyError(field);
294
+ // Only TLC's RecordValue names the field it lacks. Any other function, such as a FcnRcdValue
295
+ // whose keys are strings, reports an argument outside its domain.
296
+ return applyFunction(
297
+ value,
298
+ field,
299
+ functionClass === "record" ? describeMissing : describeNotInDomain,
300
+ );
301
+ };
302
+ };
195
303
 
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)}`;
304
+ // TLC 1.7.4 words what a tuple or a record lacks differently.
305
+ export const getMissingArgumentDescriber = (version: TlcVersion | undefined) =>
306
+ version === "1.7.4"
307
+ ? (functionValue: Value, argument: Value) =>
308
+ describeMissingArgument(functionValue, argument, version)
309
+ : undefined;
199
310
 
200
311
  export const getDomainOperator = (expression: Expression) => (value: Value) => {
201
312
  if (!isFunctionValue(value)) {
@@ -260,11 +371,23 @@ const bindPattern = (scope: Scope | undefined, pattern: BoundPattern, value: Val
260
371
  );
261
372
  };
262
373
 
374
+ // Tool#evalAppl checks that it applies a function before it evaluates the argument.
375
+ export const expectFunction = (value: Value, application: Expression) => {
376
+ if (isFunctionValue(value)) return value;
377
+ throw new TlaEvaluationError(
378
+ `A non-function (${getKindString(value)}) was applied as a function.\n${describeRange(application)}`,
379
+ );
380
+ };
381
+
382
+ export const toKeepLazyContext = (context: Context): Context =>
383
+ context.isKeepLazy ? context : { ...context, isKeepLazy: true };
384
+
263
385
  const withScope = (context: Context, scope: Scope | undefined): Context => ({
264
386
  environment: context.environment,
265
387
  scope,
266
388
  state: context.state,
267
389
  next: context.next,
390
+ isKeepLazy: context.isKeepLazy,
268
391
  });
269
392
 
270
393
  export const expectBoolean = (value: Value, description: string) => {
@@ -279,11 +402,26 @@ export const expectBoolean = (value: Value, description: string) => {
279
402
  export const getDefinition = (name: string, environment: Environment) =>
280
403
  environment.definitions.get(environment.substitutions.get(name) ?? name);
281
404
 
282
- const isStateDependent = (expression: Expression, environment: Environment): boolean => {
405
+ // TLC bounds the level of every action and temporal operator above constant, whatever its operands.
406
+ const NONCONSTANT_KINDS = new Set<Expression["kind"]>([
407
+ "Prime",
408
+ "Unchanged",
409
+ "Enabled",
410
+ "BoxAction",
411
+ "AngleAction",
412
+ "Always",
413
+ "Eventually",
414
+ "WeakFairness",
415
+ "StrongFairness",
416
+ ]);
417
+
418
+ const NONCONSTANT_OPERATORS = new Set(["~>", "-+->", "\\cdot"]);
419
+
420
+ const isNonconstant = (expression: Expression, environment: Environment): boolean => {
283
421
  if (
284
- expression.kind === "Prime" ||
285
- expression.kind === "Unchanged" ||
286
- expression.kind === "Enabled"
422
+ NONCONSTANT_KINDS.has(expression.kind) ||
423
+ (expression.kind === "UnboundedQuantifier" && expression.isTemporal === true) ||
424
+ (expression.kind === "Apply" && NONCONSTANT_OPERATORS.has(expression.operator))
287
425
  ) {
288
426
  return true;
289
427
  }
@@ -300,7 +438,7 @@ const isStateDependent = (expression: Expression, environment: Environment): boo
300
438
  if (definition && !environment.constants.has(name) && !isConstantLevel(definition, environment))
301
439
  return true;
302
440
  }
303
- return getChildren(expression).some((child) => isStateDependent(child, environment));
441
+ return getChildren(expression).some((child) => isNonconstant(child, environment));
304
442
  };
305
443
 
306
444
  export const isConstantLevel = (definition: Definition, environment: Environment): boolean => {
@@ -308,9 +446,9 @@ export const isConstantLevel = (definition: Definition, environment: Environment
308
446
  if (cached !== undefined) return cached;
309
447
  environment.constantLevels.set(definition, true);
310
448
  const isConstant =
311
- !isStateDependent(definition.body, environment) &&
449
+ !isNonconstant(definition.body, environment) &&
312
450
  (definition.kind === "Operator" ||
313
- !definition.bounds.some((bound) => isStateDependent(bound.set, environment)));
451
+ !definition.bounds.some((bound) => isNonconstant(bound.set, environment)));
314
452
  environment.constantLevels.set(definition, isConstant);
315
453
  return isConstant;
316
454
  };
@@ -333,38 +471,90 @@ const getBoundExplanation = (set: Value, text: string) => {
333
471
 
334
472
  // TLC enumerates every set except the ones it implements in Java, so any other set fails as its own
335
473
  // class does.
336
- export const getEnumeratedElements = (set: Value, expression: Expression) => {
474
+ const checkEnumerable = (set: Value, expression: Expression, version: TlcVersion) => {
337
475
  if (!isSetValue(set) || isOverriddenSet(set)) {
338
476
  const text = formatValue(set);
339
- const explanation = getBoundExplanation(set, text);
477
+ // TLC 1.7.4 doesn't explain why it can't enumerate a set.
478
+ const explanation = version === "1.7.4" ? undefined : getBoundExplanation(set, text);
340
479
  throw new TlaEvaluationError(
341
480
  explanation === undefined
342
- ? `TLC encountered a non-enumerable quantifier bound\n${text}.\n${describeRange(expression)}`
343
- : `TLC encountered the non-enumerable quantifier bound\n${text}\n${describeRange(expression)}\n${explanation}`,
481
+ ? `TLC encountered a non-enumerable quantifier bound\n${text}.\n${describeNode(expression)}`
482
+ : `TLC encountered the non-enumerable quantifier bound\n${text}\n${describeNode(expression)}\n${explanation}`,
344
483
  );
345
484
  }
346
- return typeof set === "object" && set.kind === "Interval"
347
- ? getIntervalElements(set)
348
- : toFiniteSet(set).elements;
349
485
  };
350
486
 
351
- export const forEachBinding = (
487
+ const getEnumeratedElements = (set: Value, expression: Expression, version: TlcVersion) => {
488
+ checkEnumerable(set, expression, version);
489
+ if (typeof set === "object" && set.kind === "Interval") return getIntervalElements(set);
490
+ return getLazySubsets(set) ?? toFiniteSet(set).elements;
491
+ };
492
+
493
+ // The elements Tool.contexts binds to the bound of a quantifier or a set map. TLC 1.7.4 streams a
494
+ // lazy set's elements, where later versions normalize the set first.
495
+ export const getContextElements = (set: Value, expression: Expression, version: TlcVersion) => {
496
+ if (version !== "1.7.4") return getEnumeratedElements(set, expression, version);
497
+ checkEnumerable(set, expression, version);
498
+ return getLazySubsets(set) ?? getStreamedElements(set);
499
+ };
500
+
501
+ // Like TLC, a quantifier keeps an interval as an interval, so that it can stop at the first witness
502
+ // in a large interval such as 1..2000000000 without listing it.
503
+ const getKeptInterval = (set: Value) => {
504
+ if (typeof set !== "object" || set.kind !== "Interval") return undefined;
505
+ getCardinality(set);
506
+ return set;
507
+ };
508
+
509
+ export const getQuantifierElements = (set: Value, expression: Expression, version: TlcVersion) =>
510
+ getKeptInterval(set) ?? getContextElements(set, expression, version);
511
+
512
+ // CHOOSE and a function constructor visit the elements of the normalized set.
513
+ const getNormalizedElements = (set: Value, expression: Expression, version: TlcVersion) =>
514
+ getKeptInterval(set) ?? getEnumeratedElements(set, expression, version);
515
+
516
+ const someElement = (
517
+ elements: ReturnType<typeof getQuantifierElements>,
518
+ visit: (element: Value) => boolean,
519
+ ) => {
520
+ if (Array.isArray(elements)) return elements.some(visit);
521
+ for (let element = elements.low; element <= elements.high; element++) {
522
+ if (visit(element)) return true;
523
+ }
524
+ return false;
525
+ };
526
+
527
+ export const getBoundElements = (bounds: Bound[], context: Context) =>
528
+ bounds.map((bound) =>
529
+ getQuantifierElements(
530
+ evaluate(bound.set, context),
531
+ bound.set,
532
+ context.environment.runtime.version,
533
+ ),
534
+ );
535
+
536
+ // Visits each binding of the bounds to the elements of their sets, until visit returns true.
537
+ export const forEachBoundElement = (
352
538
  bounds: Bound[],
353
- context: Context,
539
+ sets: ReturnType<typeof getBoundElements>,
540
+ scope: Scope | undefined,
354
541
  visit: (scope: Scope | undefined) => boolean,
355
542
  ): boolean => {
356
- const sets = bounds.map((bound) =>
357
- getEnumeratedElements(evaluate(bound.set, context), bound.set),
358
- );
359
- const visitBound = (index: number, scope: Scope | undefined): boolean => {
360
- if (index < 0) return visit(scope);
361
- return sets[index].some((element) =>
362
- visitBound(index - 1, bindPattern(scope, bounds[index].pattern, element)),
543
+ const visitBound = (index: number, bound: Scope | undefined): boolean => {
544
+ if (index < 0) return visit(bound);
545
+ return someElement(sets[index], (element) =>
546
+ visitBound(index - 1, bindPattern(bound, bounds[index].pattern, element)),
363
547
  );
364
548
  };
365
- return visitBound(bounds.length - 1, context.scope);
549
+ return visitBound(bounds.length - 1, scope);
366
550
  };
367
551
 
552
+ export const forEachBinding = (
553
+ bounds: Bound[],
554
+ context: Context,
555
+ visit: (scope: Scope | undefined) => boolean,
556
+ ) => forEachBoundElement(bounds, getBoundElements(bounds, context), context.scope, visit);
557
+
368
558
  export const getBoundsDomain = (bounds: Bound[], context: Context): Value => {
369
559
  const sets = bounds.map((bound) => evaluate(bound.set, context));
370
560
  return sets.length === 1 ? sets[0] : { kind: "ProductSet", factors: sets };
@@ -379,6 +569,80 @@ export const bindArgument = (bounds: Bound[], scope: Scope | undefined, argument
379
569
  );
380
570
  };
381
571
 
572
+ // The parameters, body and scope of each function a constructor or a definition keeps lazy, whose
573
+ // body TLC's getInitStates and getNextStates walk for an argument, as they do a FcnLambdaValue's.
574
+ interface LazyFunction {
575
+ value: LazyFunctionValue;
576
+ bounds: Bound[];
577
+ body: Expression;
578
+ scope: Scope | undefined;
579
+ }
580
+
581
+ const lazyFunctions = new WeakMap<LazyFunctionValue, LazyFunction>();
582
+
583
+ const keepLambda = (lambda: LazyFunction) => {
584
+ lazyFunctions.set(lambda.value, lambda);
585
+ return lambda.value;
586
+ };
587
+
588
+ export const getLazyFunction = (value: Value) =>
589
+ typeof value === "object" && value.kind === "LazyFunction" ? lazyFunctions.get(value) : undefined;
590
+
591
+ // Tool.getFcnContext: the scope of a lazy function's body for the arguments of an application. It
592
+ // ignores arguments beyond the parameters.
593
+ export const bindLazyArguments = (
594
+ lambda: LazyFunction,
595
+ expression: Expression & { kind: "FunctionApplication" },
596
+ context: Context,
597
+ ) => {
598
+ const value = lambda.value;
599
+ const args = expression.args.map((arg) => evaluate(arg, context));
600
+ const argument = args.length === 1 ? args[0] : createTuple(args);
601
+ const describeArgument = (ordinal: string, element: Value, problem: string) =>
602
+ `In applying the function\n${prettyPrint(formatValue(value))},\nthe ${ordinal} is:\n${prettyPrint(formatValue(element))}${problem}.\n${describeRange(expression.function)}`;
603
+ const bounds = lambda.bounds;
604
+ if (bounds.length === 1) {
605
+ if (!isElementOf(argument, value.domain)) {
606
+ throw new TlaEvaluationError(
607
+ describeArgument("first argument", argument, "which is not in its domain"),
608
+ );
609
+ }
610
+ return bindArgument(bounds, lambda.scope, argument);
611
+ }
612
+ const elements = getSequenceElements(argument);
613
+ const domains =
614
+ typeof value.domain === "object" && value.domain.kind === "ProductSet"
615
+ ? value.domain.factors
616
+ : [];
617
+ if (elements === undefined || elements.length < bounds.length) {
618
+ throw new TlaEvaluationError(
619
+ `Attempted to apply a function to an argument not in its domain.\n${describeRange(expression.function)}`,
620
+ );
621
+ }
622
+ bounds.forEach((bound, index) => {
623
+ const element = elements[index];
624
+ const ordinal = `argument number ${index + 1}`;
625
+ if (!isElementOf(element, domains[index])) {
626
+ throw new TlaEvaluationError(
627
+ describeArgument(
628
+ ordinal,
629
+ element,
630
+ `${bound.pattern.kind === "Name" ? "" : "\n"}which is not in its domain`,
631
+ ),
632
+ );
633
+ }
634
+ if (
635
+ bound.pattern.kind === "Tuple" &&
636
+ getSequenceElements(element)?.length !== bound.pattern.names.length
637
+ ) {
638
+ throw new TlaEvaluationError(
639
+ describeArgument(ordinal, element, "which does not match its formal parameter"),
640
+ );
641
+ }
642
+ });
643
+ return bindArgument(bounds, lambda.scope, createTuple(elements.slice(0, bounds.length)));
644
+ };
645
+
382
646
  // TLC prints a function it can't enumerate as its parameters and the location of its body. It
383
647
  // prints only the first name of a group such as `m, n \in S`.
384
648
  interface LazyFunctionTemplate {
@@ -457,6 +721,22 @@ const createLazyFunction = (
457
721
  return self;
458
722
  };
459
723
 
724
+ const definitionSources = new WeakMap<FunctionDefinition, Expression>();
725
+
726
+ // The function constructor of a definition, which SANY locates at the whole definition.
727
+ const getDefinitionSource = (definition: FunctionDefinition) => {
728
+ const cached = definitionSources.get(definition);
729
+ if (cached) return cached;
730
+ const source: Expression = {
731
+ kind: "FunctionConstruction",
732
+ bounds: definition.bounds,
733
+ body: definition.body,
734
+ location: definition.location,
735
+ };
736
+ definitionSources.set(definition, source);
737
+ return source;
738
+ };
739
+
460
740
  const createRecursiveFunction = (definition: FunctionDefinition, context: Context) => {
461
741
  const domain = getBoundsDomain(definition.bounds, context);
462
742
  const functionValue = createLazyFunction(
@@ -471,13 +751,44 @@ const createRecursiveFunction = (definition: FunctionDefinition, context: Contex
471
751
  ),
472
752
  getLazyFunctionSource(definition.bounds, definition.body, domain),
473
753
  );
754
+ keepLambda({
755
+ value: functionValue,
756
+ bounds: definition.bounds,
757
+ body: definition.body,
758
+ scope: bindValue(undefined, definition.name, functionValue),
759
+ });
474
760
  return definition.bounds.length === 1 ? markLambdaFunction(functionValue) : functionValue;
475
761
  };
476
762
 
477
- const evaluateDefinitionBody = (definition: Definition, context: Context) =>
478
- definition.kind === "Function"
763
+ // TLC computes a constant definition when it starts, without keeping a function it constructs
764
+ // lazy, so a function over an interval or an enumerated set is a FcnRcdValue.
765
+ const toStartupValue = (definition: Definition, value: Value): Value => {
766
+ if (typeof value !== "object" || getFunctionClass(value) !== "lambda") return value;
767
+ if (
768
+ definition.kind === "Operator" ||
769
+ definition.isSelfReferential ||
770
+ value.kind !== "LazyFunction" ||
771
+ !isReducibleSet(value.domain)
772
+ ) {
773
+ return value;
774
+ }
775
+ try {
776
+ const finite = toFiniteFunction(value);
777
+ return createSortedFunction(finite.domain, finite.range);
778
+ } catch (error) {
779
+ // TLC leaves a definition it fails to compute to evaluate where the spec uses it.
780
+ if (error instanceof TlaEvaluationError) return value;
781
+ throw error;
782
+ }
783
+ };
784
+
785
+ // TLC evaluates a function definition that isn't recursive as it does a function constructor.
786
+ const evaluateDefinitionBody = (definition: Definition, context: Context) => {
787
+ if (definition.kind !== "Function") return evaluate(definition.body, context);
788
+ return definition.isSelfReferential
479
789
  ? createRecursiveFunction(definition, context)
480
- : evaluate(definition.body, context);
790
+ : evaluate(getDefinitionSource(definition), context);
791
+ };
481
792
 
482
793
  const evaluateDefinitionValue = (definition: Definition, context: Context) => {
483
794
  const isConstant = isConstantLevel(definition, context.environment);
@@ -491,12 +802,35 @@ const evaluateDefinitionValue = (definition: Definition, context: Context) => {
491
802
  const topLevel = withScope(context, undefined);
492
803
  if (!isConstant) return evaluateDefinitionBody(definition, topLevel);
493
804
  const value = context.environment.runtime.evaluateAtStartup(() =>
494
- evaluateDefinitionBody(definition, topLevel),
805
+ toStartupValue(definition, evaluateDefinitionBody(definition, topLevel)),
495
806
  );
496
807
  context.environment.definitionValues.set(definition, value);
497
808
  return value;
498
809
  };
499
810
 
811
+ // TLC computes each constant definition the configuration doesn't replace when it starts, and
812
+ // leaves one it fails to compute to evaluate where the spec uses it.
813
+ export const evaluateStartupDefinitions = (definitions: Definition[], environment: Environment) =>
814
+ definitions.forEach((definition) => {
815
+ if (definition.kind === "Operator" && definition.params.length > 0) return;
816
+ const name = definition.name;
817
+ if (environment.constants.has(name) || environment.substitutions.has(name)) return;
818
+ if (!isConstantLevel(definition, environment)) return;
819
+ try {
820
+ markNormalized(
821
+ evaluateDefinitionValue(definition, {
822
+ environment,
823
+ scope: undefined,
824
+ state: undefined,
825
+ next: undefined,
826
+ }),
827
+ );
828
+ } catch (error) {
829
+ // TLC swallows whatever the definition throws, a stack overflow included.
830
+ if (!(error instanceof TlaEvaluationError) && !isStackOverflow(error)) throw error;
831
+ }
832
+ });
833
+
500
834
  const forceThunk = (thunk: Thunk, context: Context) => {
501
835
  const isSameState = thunk.state === context.state && thunk.next === context.next;
502
836
  if (isSameState && thunk.cache !== undefined) return thunk.cache;
@@ -872,10 +1206,24 @@ const isImpureDefinition = (
872
1206
  return isImpure;
873
1207
  };
874
1208
 
1209
+ // UNION and \cup build sets that stream the sets they combine until TLC caches them, and TLC
1210
+ // builds a new one at each evaluation.
1211
+ const STREAMED_SET: Impurity = {
1212
+ builtins: new Set(["UNION", "\\cup"]),
1213
+ definitions: new WeakMap(),
1214
+ };
1215
+
875
1216
  // TLC's next-state generator does not bind LET definitions to values, so each reference to one
876
- // that calls an impure builtin evaluates it again.
1217
+ // evaluates it again: one that calls an impure builtin repeats its effects, and a set one builds
1218
+ // with UNION or \cup starts out uncached.
877
1219
  export const getReevaluatedDefinitions = (definitions: Definition[], environment: Environment) =>
878
- new Set(definitions.filter((definition) => isImpureDefinition(definition, environment)));
1220
+ new Set(
1221
+ definitions.filter(
1222
+ (definition) =>
1223
+ isImpureDefinition(definition, environment) ||
1224
+ isImpureDefinition(definition, environment, STREAMED_SET),
1225
+ ),
1226
+ );
879
1227
 
880
1228
  export const isImpure = (environment: Environment) =>
881
1229
  [...environment.definitions.values()].some((definition) =>
@@ -951,7 +1299,11 @@ const computeIsClosedConstant = (
951
1299
  return global?.kind === "Definition" && isEvaluatedOnce(global.definition, environment);
952
1300
  }
953
1301
  if (expression.kind === "Apply") {
954
- if (isImpureBuiltin(expression.operator, environment) || expression.operator === "~>") {
1302
+ if (
1303
+ isImpureBuiltin(expression.operator, environment) ||
1304
+ STREAMED_SET.builtins.has(expression.operator) ||
1305
+ expression.operator === "~>"
1306
+ ) {
955
1307
  return false;
956
1308
  }
957
1309
  const operator = resolveGlobalOperator(expression.operator, environment);
@@ -1023,12 +1375,127 @@ const isStateCached = (expression: Expression, environment: Environment) =>
1023
1375
  getReadVariables(expression, environment) !== undefined &&
1024
1376
  !hasFreeLocals(expression, NO_BOUND_NAMES);
1025
1377
 
1378
+ // How to rebuild a set filter TLC evaluates lazily so that its predicate runs in another
1379
+ // environment.
1380
+ const filteredSetRebinders = new WeakMap<FilteredSetValue, (environment: Environment) => Value>();
1381
+
1382
+ // TLC's CallStackTool rebinds the lazy values its evaluations return, so their later evaluation
1383
+ // records its call stack too.
1384
+ const traceEvaluator =
1385
+ (
1386
+ expression: Expression,
1387
+ evaluator: Evaluator,
1388
+ environment: Environment,
1389
+ callStack: CallStack,
1390
+ ): Evaluator =>
1391
+ (context) => {
1392
+ callStack.expressions.push(expression);
1393
+ const outerSets = setTrace.sets;
1394
+ const outerCallStack = setTrace.callStack;
1395
+ const sets = outerSets ?? [];
1396
+ const depth = sets.length;
1397
+ setTrace.sets = sets;
1398
+ setTrace.callStack = callStack;
1399
+ try {
1400
+ const computed = evaluator(context);
1401
+ const rebind =
1402
+ typeof computed === "object" && computed.kind === "FilteredSet"
1403
+ ? filteredSetRebinders.get(computed)
1404
+ : undefined;
1405
+ const value = rebind ? rebind(environment) : computed;
1406
+ callStack.values.set(expression, value);
1407
+ if (typeof value === "object" && value.kind !== "FilteredSet" && isSourced(expression)) {
1408
+ callStack.sources.set(value, expression);
1409
+ }
1410
+ return value;
1411
+ } catch (error) {
1412
+ const failed = error instanceof Error ? callStack.failures.get(error) : undefined;
1413
+ if (error instanceof Error) callStack.failures.set(error, expression);
1414
+ const receiver = getReceiver(expression, callStack.values);
1415
+ const received =
1416
+ receiver && !getChildren(expression).some((child) => child === failed)
1417
+ ? callStack.values.get(receiver)
1418
+ : undefined;
1419
+ const value =
1420
+ expression.kind === "FunctionApplication" &&
1421
+ received !== undefined &&
1422
+ !isFunctionValue(received)
1423
+ ? undefined
1424
+ : received;
1425
+ freezeCallStack(
1426
+ callStack,
1427
+ [value, ...sets.slice(depth).filter((set) => set !== value)],
1428
+ error,
1429
+ );
1430
+ throw error;
1431
+ } finally {
1432
+ if (!callStack.isFrozen) callStack.expressions.pop();
1433
+ sets.length = depth;
1434
+ setTrace.sets = outerSets;
1435
+ setTrace.callStack = outerCallStack;
1436
+ }
1437
+ };
1438
+
1439
+ // A method of a value with a source raises a FingerprintException, which each value with a source
1440
+ // whose method called it heads in turn. CallStack#freeze adds their sources to the stack, outermost
1441
+ // first. The values are those whose methods failed, outermost first.
1442
+ export const freezeCallStack = (
1443
+ callStack: CallStack,
1444
+ values: (Value | undefined)[],
1445
+ error: unknown,
1446
+ ) => {
1447
+ // A set that streams its elements enumerates itself too, so it can appear twice.
1448
+ const sources = [...new Set(values)].flatMap((item) => {
1449
+ const source = typeof item === "object" ? callStack.sources.get(item) : undefined;
1450
+ return source ? [source] : [];
1451
+ });
1452
+ // A value with a source raises a FingerprintException even when the stack is frozen already.
1453
+ if (sources.length > 0 && error instanceof TlaEvaluationError) {
1454
+ if (!callStack.isFrozen) callStack.expressions.push(...sources);
1455
+ const inner = callStack.fingerprint;
1456
+ callStack.fingerprint = {
1457
+ sources: [...sources, ...(inner?.sources ?? [])],
1458
+ reason: inner?.reason ?? error.message,
1459
+ };
1460
+ }
1461
+ callStack.isFrozen = true;
1462
+ };
1463
+
1464
+ // A FingerprintException that a method of a value with a source raises, or that passes through one,
1465
+ // takes the value's source as its new head.
1466
+ const headFingerprint = (callStack: CallStack, source: Expression, error: unknown) => {
1467
+ if (!(error instanceof TlaEvaluationError)) return;
1468
+ if (!callStack.isFrozen) callStack.expressions.push(source);
1469
+ callStack.isFrozen = true;
1470
+ const inner = callStack.fingerprint;
1471
+ callStack.fingerprint = {
1472
+ sources: [source, ...(inner?.sources ?? [])],
1473
+ reason: inner?.reason ?? error.message,
1474
+ };
1475
+ };
1476
+
1477
+ // A copy of the environment that records the call stack of each evaluation, with evaluators of its
1478
+ // own since the environment's evaluators record nothing.
1479
+ export const createTracingEnvironment = (environment: Environment): Environment => ({
1480
+ ...environment,
1481
+ evaluators: new WeakMap(),
1482
+ callStack: {
1483
+ expressions: [],
1484
+ isFrozen: false,
1485
+ sources: new WeakMap(),
1486
+ values: new WeakMap(),
1487
+ failures: new WeakMap(),
1488
+ },
1489
+ });
1490
+
1026
1491
  export const getEvaluator = (expression: Expression, environment: Environment): Evaluator => {
1027
1492
  const cached = environment.evaluators.get(expression);
1028
1493
  if (cached) return cached;
1029
1494
  const compiled = compile(expression, environment);
1030
- const evaluator =
1031
- isWorthCaching(expression) && isClosedConstant(expression, environment)
1495
+ const callStack = environment.callStack;
1496
+ const evaluator = callStack
1497
+ ? traceEvaluator(expression, compiled, environment, callStack)
1498
+ : isWorthCaching(expression) && isClosedConstant(expression, environment)
1032
1499
  ? cacheFirstValue(compiled)
1033
1500
  : isStateCached(expression, environment)
1034
1501
  ? cacheStateValue(compiled)
@@ -1039,7 +1506,8 @@ export const getEvaluator = (expression: Expression, environment: Environment):
1039
1506
 
1040
1507
  const entryEvaluators = new WeakMap<Expression, Evaluator>();
1041
1508
 
1042
- export const getEntryEvaluator = (expression: Expression, environment: Environment) => {
1509
+ const getEntryEvaluator = (expression: Expression, environment: Environment) => {
1510
+ if (environment.callStack) return getEvaluator(expression, environment);
1043
1511
  const cached = entryEvaluators.get(expression);
1044
1512
  if (cached) return cached;
1045
1513
  const evaluator =
@@ -1263,14 +1731,21 @@ const compileClosureCall = (
1263
1731
  const compiled = { body: undefined as Evaluator | undefined };
1264
1732
  const evaluateBody = (scope: Scope | undefined, context: Context) => {
1265
1733
  compiled.body ??= getEntryEvaluator(closure.body, environment);
1266
- return compiled.body({ environment, scope, state: context.state, next: context.next });
1734
+ return compiled.body({
1735
+ environment,
1736
+ scope,
1737
+ state: context.state,
1738
+ next: context.next,
1739
+ isKeepLazy: context.isKeepLazy,
1740
+ });
1267
1741
  };
1268
1742
  if (!isMemoized) return (context) => evaluateBody(bindArguments(context), context);
1269
1743
  const memo = getCallMemo(closure);
1270
1744
  return (context) => {
1271
1745
  const scope = bindArguments(context);
1272
1746
  const values = getArgumentValues(scope, args.length);
1273
- if (!values) return evaluateBody(scope, context);
1747
+ // A call TLC evaluates with EvalControl.KeepLazy builds what a memoized one wouldn't.
1748
+ if (!values || context.isKeepLazy) return evaluateBody(scope, context);
1274
1749
  let hash = values.length;
1275
1750
  for (const value of values) hash = combineHash(hash, getValueHash(value));
1276
1751
  const bucket = memo.calls.get(hash);
@@ -1307,7 +1782,9 @@ const compileApply = (
1307
1782
  ? undefined
1308
1783
  : resolveGlobalOperator(expression.operator, environment);
1309
1784
  if (global?.kind === "Closure") {
1310
- return compileClosureCall(global, args, environment, isMemoizable(expression, environment));
1785
+ // The replay records the evaluation of each call, which TLC repeats.
1786
+ const isMemoized = !environment.callStack && isMemoizable(expression, environment);
1787
+ return compileClosureCall(global, args, environment, isMemoized);
1311
1788
  }
1312
1789
  if (global?.kind === "Builtin" && global.name === "DOMAIN") {
1313
1790
  const operand = getEvaluator(args[0], environment);
@@ -1317,7 +1794,7 @@ const compileApply = (
1317
1794
  // TLC sorts the value of a constant TLCEval argument only where no context binds a name.
1318
1795
  if (global?.kind === "Builtin" && global.name === "TLCEval" && args.length === 1) {
1319
1796
  const operand = getEvaluator(args[0], environment);
1320
- if (contextualApplications.has(expression) || isStateDependent(args[0], environment)) {
1797
+ if (contextualApplications.has(expression) || isNonconstant(args[0], environment)) {
1321
1798
  return operand;
1322
1799
  }
1323
1800
  return (context) =>
@@ -1330,6 +1807,16 @@ const compileApply = (
1330
1807
  return (context) => subset(left(context), right(context));
1331
1808
  }
1332
1809
  if (global?.kind === "Builtin") return compileBuiltinCall(global, args, environment);
1810
+ // TLC refuses action composition unless a Java property enables its incomplete implementation.
1811
+ if (expression.operator === "\\cdot" && args.length === 2) {
1812
+ return () => {
1813
+ throw new TlaEvaluationError(
1814
+ environment.runtime.version === "1.7.4"
1815
+ ? "The current version of TLC does not support action composition."
1816
+ : "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.",
1817
+ );
1818
+ };
1819
+ }
1333
1820
  return (context) => {
1334
1821
  const operator = resolveOperator(expression.operator, context);
1335
1822
  if (operator) return callOperator(operator, args, context);
@@ -1337,11 +1824,6 @@ const compileApply = (
1337
1824
  if (definition?.kind === "Function") {
1338
1825
  throw new TlaEvaluationError(`${expression.operator} is a function; apply it with brackets`);
1339
1826
  }
1340
- if (expression.operator === "\\cdot") {
1341
- throw new TlaEvaluationError(
1342
- "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.",
1343
- );
1344
- }
1345
1827
  throw new TlaEvaluationError(
1346
1828
  `Unknown operator ${expression.operator} at ${describeLocation(expression)}`,
1347
1829
  );
@@ -1360,15 +1842,15 @@ const compileQuantifier = (
1360
1842
  const name = bound.pattern.name;
1361
1843
  const set = getEvaluator(bound.set, environment);
1362
1844
  return (context) => {
1363
- const elements = getEnumeratedElements(set(context), bound.set);
1364
- for (let index = 0; index < elements.length; index++) {
1365
- const result = expectBoolean(
1366
- body(withScope(context, bindValue(context.scope, name, elements[index]))),
1367
- description,
1368
- );
1369
- if (result !== isForall) return result;
1370
- }
1371
- return isForall;
1845
+ const isFound = someElement(
1846
+ getQuantifierElements(set(context), bound.set, environment.runtime.version),
1847
+ (element) =>
1848
+ expectBoolean(
1849
+ body(withScope(context, bindValue(context.scope, name, element))),
1850
+ description,
1851
+ ) !== isForall,
1852
+ );
1853
+ return isFound ? !isForall : isForall;
1372
1854
  };
1373
1855
  }
1374
1856
  const bounds = expression.bounds;
@@ -1377,17 +1859,15 @@ const compileQuantifier = (
1377
1859
  const sets = bounds.map((item) => getEvaluator(item.set, environment));
1378
1860
  return (context) => {
1379
1861
  const lists = sets.map((set, index) =>
1380
- getEnumeratedElements(set(context), bounds[index].set),
1862
+ getQuantifierElements(set(context), bounds[index].set, environment.runtime.version),
1381
1863
  );
1382
1864
  const visit = (index: number, scope: Scope | undefined): boolean => {
1383
1865
  if (index < 0) {
1384
1866
  return expectBoolean(body(withScope(context, scope)), description) !== isForall;
1385
1867
  }
1386
- const list = lists[index];
1387
- for (let position = 0; position < list.length; position++) {
1388
- if (visit(index - 1, bindValue(scope, names[index], list[position]))) return true;
1389
- }
1390
- return false;
1868
+ return someElement(lists[index], (element) =>
1869
+ visit(index - 1, bindValue(scope, names[index], element)),
1870
+ );
1391
1871
  };
1392
1872
  return visit(bounds.length - 1, context.scope) ? !isForall : isForall;
1393
1873
  };
@@ -1435,34 +1915,26 @@ const compileFunctionConstruction = (
1435
1915
  const bound = bounds[0];
1436
1916
  const isSingleName = bounds.length === 1 && bound.pattern.kind === "Name";
1437
1917
  const set = getEvaluator(bound.set, environment);
1438
- return (context) => {
1439
- const domain = isSingleName ? set(context) : getBoundsDomain(bounds, context);
1440
- // TLC builds the function only when it reduces every domain, and evaluates the body lazily
1441
- // otherwise.
1442
- const domains =
1443
- typeof domain === "object" && domain.kind === "ProductSet" && bounds.length > 1
1444
- ? domain.factors
1445
- : [domain];
1446
- if (expression.isRecursive || isKeptLazy || !domains.every(isReducible)) {
1447
- const functionValue = createLazyFunction(
1448
- domain,
1449
- (argument) => body(withScope(context, bindArgument(bounds, context.scope, argument))),
1450
- getLazyFunctionSource(bounds, expression.body, domain),
1451
- );
1452
- return bounds.length === 1 ? markLambdaFunction(functionValue) : functionValue;
1453
- }
1918
+ const construct = (domain: Value, context: Context) => {
1454
1919
  if (isSingleName && bound.pattern.kind === "Name") {
1455
1920
  const name = bound.pattern.name;
1456
1921
  const keys = getFunctionDomain(domain);
1457
- return markLambdaFunction(
1458
- createSortedFunction(
1459
- keys,
1460
- keys.map((key) => body(withScope(context, bindValue(context.scope, name, key)))),
1461
- ),
1922
+ const functionValue = createSortedFunction(
1923
+ keys,
1924
+ keys.map((key) => body(withScope(context, bindValue(context.scope, name, key)))),
1462
1925
  );
1926
+ // FcnLambdaValue#toFcnRcd builds a FcnRcdValue over an interval or an enumerated set.
1927
+ return isReducibleSet(domain) ? functionValue : markLambdaFunction(functionValue);
1463
1928
  }
1464
1929
  const pairs: [Value, Value][] = [];
1465
- forEachBinding(bounds, context, (scope) => {
1930
+ const sets = bounds.map((item) =>
1931
+ getNormalizedElements(
1932
+ evaluate(item.set, context),
1933
+ item.set,
1934
+ context.environment.runtime.version,
1935
+ ),
1936
+ );
1937
+ forEachBoundElement(bounds, sets, context.scope, (scope) => {
1466
1938
  const key =
1467
1939
  bounds.length === 1
1468
1940
  ? (lookupKey(bound.pattern, scope) ?? false)
@@ -1472,6 +1944,46 @@ const compileFunctionConstruction = (
1472
1944
  });
1473
1945
  return createFunction(pairs);
1474
1946
  };
1947
+ const createLazy = (domain: Value, context: Context) => {
1948
+ const functionValue = keepLambda({
1949
+ value: createLazyFunction(
1950
+ domain,
1951
+ (argument) => body(withScope(context, bindArgument(bounds, context.scope, argument))),
1952
+ getLazyFunctionSource(bounds, expression.body, domain),
1953
+ ),
1954
+ bounds,
1955
+ body: expression.body,
1956
+ scope: context.scope,
1957
+ });
1958
+ return bounds.length === 1 ? markLambdaFunction(functionValue) : functionValue;
1959
+ };
1960
+ const callStack = environment.callStack;
1961
+ return (context) => {
1962
+ const domain = isSingleName ? set(context) : getBoundsDomain(bounds, context);
1963
+ if (expression.isRecursive || isKeptLazy || context.isKeepLazy || !isEnumerable(domain)) {
1964
+ return createLazy(domain, context);
1965
+ }
1966
+ // TLC builds a function over a domain other than a set enumeration or an interval lazily, so
1967
+ // its body fails only where TLC forces it, as the replay does. Building it at once is faster
1968
+ // otherwise.
1969
+ if (!isReducibleSet(domain)) {
1970
+ if (callStack) return createLazy(domain, context);
1971
+ try {
1972
+ return construct(domain, context);
1973
+ } catch (error) {
1974
+ if (!(error instanceof TlaEvaluationError)) throw error;
1975
+ return createLazy(domain, context);
1976
+ }
1977
+ }
1978
+ if (!callStack) return construct(domain, context);
1979
+ // TLC builds the function in a method of the FcnLambdaValue that CallStackTool gives a source.
1980
+ try {
1981
+ return construct(domain, context);
1982
+ } catch (error) {
1983
+ headFingerprint(callStack, expression, error);
1984
+ throw error;
1985
+ }
1986
+ };
1475
1987
  };
1476
1988
 
1477
1989
  const compileExcept = (
@@ -1517,7 +2029,20 @@ const compileExcept = (
1517
2029
  };
1518
2030
  return (context) => {
1519
2031
  let current = evaluateFunction(context);
1520
- for (const item of updates) current = update(current, item.path, 0, context, item.value);
2032
+ for (const item of updates) {
2033
+ // TLC leaves the value as it is when an update's path is not in it, and warns.
2034
+ const found = { value: false };
2035
+ current = update(current, item.path, 0, context, (inner) => {
2036
+ found.value = true;
2037
+ return item.value(inner);
2038
+ });
2039
+ if (!found.value) {
2040
+ context.environment.runtime.warn(
2041
+ MESSAGE_CODE.exceptAppliedToUnknownField,
2042
+ `The EXCEPT was applied to non-existing fields of the value at\n${describeRange(expression.function)}`,
2043
+ );
2044
+ }
2045
+ }
1521
2046
  return current;
1522
2047
  };
1523
2048
  };
@@ -1530,20 +2055,41 @@ const compileSetComprehension = (
1530
2055
  const predicate = getEvaluator(expression.predicate, environment);
1531
2056
  const set = getEvaluator(expression.bound.set, environment);
1532
2057
  const pattern = expression.bound.pattern;
2058
+ const range = expression.predicate.location.range;
2059
+ const source = range && {
2060
+ names: pattern.kind === "Name" ? pattern.name : pattern.names.join(", "),
2061
+ predicate: formatRange(range),
2062
+ };
2063
+ const createTest = (evaluator: Evaluator, context: Context) => (element: Value) =>
2064
+ expectBoolean(
2065
+ evaluator(withScope(context, bindPattern(context.scope, pattern, element))),
2066
+ "a set filter predicate",
2067
+ );
2068
+ const createFiltered = (
2069
+ base: Value,
2070
+ context: Context,
2071
+ evaluator: Evaluator,
2072
+ ): FilteredSetValue => {
2073
+ const filtered: FilteredSetValue = {
2074
+ kind: "FilteredSet",
2075
+ base,
2076
+ test: createTest(evaluator, context),
2077
+ source,
2078
+ };
2079
+ filteredSetRebinders.set(filtered, (tracing) =>
2080
+ createFiltered(
2081
+ base,
2082
+ { ...context, environment: tracing },
2083
+ getEvaluator(expression.predicate, tracing),
2084
+ ),
2085
+ );
2086
+ return filtered;
2087
+ };
1533
2088
  return (context) => {
1534
2089
  const base = set(context);
1535
- const test = (element: Value) =>
1536
- expectBoolean(
1537
- predicate(withScope(context, bindPattern(context.scope, pattern, element))),
1538
- "a set filter predicate",
1539
- );
1540
- if (!isReducible(base)) {
1541
- if (isSetValue(base)) return { kind: "FilteredSet", base, test };
1542
- throw new TlaEvaluationError(
1543
- `TLC encountered a non-enumerable quantifier bound ${formatValue(base)} at ${describeLocation(expression.bound.set)}`,
1544
- );
1545
- }
1546
- return createSortedSet(toFiniteSet(base).elements.filter(test));
2090
+ // TLC filters any value it can't enumerate lazily, and fails only when it uses the result.
2091
+ if (!isReducibleSet(base)) return createFiltered(base, context, predicate);
2092
+ return createSortedSet(toFiniteSet(base).elements.filter(createTest(predicate, context)));
1547
2093
  };
1548
2094
  }
1549
2095
  if (expression.kind === "SetMap") {
@@ -1566,10 +2112,18 @@ const compileSetComprehension = (
1566
2112
  };
1567
2113
  }
1568
2114
  const body = getEvaluator(expression.body, environment);
1569
- const bound = { pattern: expression.pattern, set };
2115
+ const evaluateSet = getEvaluator(set, environment);
1570
2116
  return (context) => {
2117
+ const base = evaluateSet(context);
2118
+ if (!isSetValue(base) || isOverriddenSet(base)) {
2119
+ throw new TlaEvaluationError(
2120
+ `Attempted to compute the value of an expression of\nform CHOOSE x \\in S: P, but S was not enumerable.\n${describeRange(expression)}`,
2121
+ );
2122
+ }
1571
2123
  const chosen = { value: undefined as Value | undefined };
1572
- forEachBinding([bound], context, (scope) => {
2124
+ const elements = getNormalizedElements(base, set, context.environment.runtime.version);
2125
+ someElement(elements, (element) => {
2126
+ const scope = bindPattern(context.scope, expression.pattern, element);
1573
2127
  if (!expectBoolean(body(withScope(context, scope)), "the body of CHOOSE")) return false;
1574
2128
  chosen.value = lookupKey(expression.pattern, scope);
1575
2129
  return true;
@@ -1590,14 +2144,22 @@ export const getSortedFields = (fields: RecordField[]) =>
1590
2144
  export const hasDuplicateFields = (sortedFields: RecordField[]) =>
1591
2145
  sortedFields.some((field, index) => index > 0 && sortedFields[index - 1].name === field.name);
1592
2146
 
2147
+ // TLC's Tool#evalAppl fails to look up a variable the state doesn't assign.
1593
2148
  export const createUnassignedError = (name: string, expression: Expression) =>
1594
- setOwnExitCode(
1595
- new TlaEvaluationError(
1596
- `In evaluation, the identifier ${name} is either undefined or not an operator.\n${describeRange(expression)}`,
1597
- ),
1598
- EXIT_STATUS.configParseError,
2149
+ new TlaUnassignedError(
2150
+ `In evaluation, the identifier ${name} is either undefined or not an operator.\n${describeRange(expression)}`,
2151
+ name,
1599
2152
  );
1600
2153
 
2154
+ // TLC's Tool#enabled reads the subscript of <<A>>_v in the successor as a state of its own, and
2155
+ // names the fairness condition when A leaves a variable of v unassigned, unlike TLC 1.7.4's.
2156
+ export const toUnspecifiedSubscriptError = (error: unknown, version: TlcVersion | undefined) =>
2157
+ error instanceof TlaUnassignedError && version !== "1.7.4"
2158
+ ? new TlaEvaluationError(
2159
+ `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`,
2160
+ )
2161
+ : error;
2162
+
1601
2163
  export const createPrimeOutsideActionError = (expression: Expression) =>
1602
2164
  new TlaEvaluationError(
1603
2165
  `A primed expression appears outside an action at ${describeLocation(expression)}`,
@@ -1609,8 +2171,8 @@ const compileRecord = (recordFields: RecordField[], environment: Environment): E
1609
2171
  const values = fields.map((field) => getEvaluator(field.value, environment));
1610
2172
  if (hasDuplicates) {
1611
2173
  return (context) =>
1612
- createFunction(
1613
- fields.map((field, index): [Value, Value] => [field.name, values[index](context)]),
2174
+ createRecord(
2175
+ fields.map((field, index): [string, Value] => [field.name, values[index](context)]),
1614
2176
  );
1615
2177
  }
1616
2178
  const names = fields.map((field) => field.name);
@@ -1624,7 +2186,7 @@ const compileRecord = (recordFields: RecordField[], environment: Environment): E
1624
2186
  );
1625
2187
  }
1626
2188
  return (context) =>
1627
- createSortedFunction(
2189
+ createSortedRecord(
1628
2190
  names,
1629
2191
  values.map((value) => value(context)),
1630
2192
  );
@@ -1653,6 +2215,12 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
1653
2215
  return compileIdentifier(expression, environment);
1654
2216
  case "Apply":
1655
2217
  return compileApply(expression, environment);
2218
+ case "Bracket":
2219
+ return () => {
2220
+ throw new TlaEvaluationError(
2221
+ `A bracket without a function or subscript is not an expression at ${describeLocation(expression)}`,
2222
+ );
2223
+ };
1656
2224
  case "OperatorReference":
1657
2225
  case "Lambda":
1658
2226
  return () => {
@@ -1665,7 +2233,7 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
1665
2233
  return (context) => {
1666
2234
  for (let index = 0; index < operands.length; index++) {
1667
2235
  const value = operands[index](context);
1668
- if (typeof value !== "boolean") throw getConjunctError(expression, index, value);
2236
+ if (typeof value !== "boolean") throw getJunctionError(expression, index, value);
1669
2237
  if (!value) return false;
1670
2238
  }
1671
2239
  return true;
@@ -1675,7 +2243,9 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
1675
2243
  const operands = expression.operands.map(child);
1676
2244
  return (context) => {
1677
2245
  for (let index = 0; index < operands.length; index++) {
1678
- if (expectBoolean(operands[index](context), "a disjunct")) return true;
2246
+ const value = operands[index](context);
2247
+ if (typeof value !== "boolean") throw getJunctionError(expression, index, value);
2248
+ if (value) return true;
1679
2249
  }
1680
2250
  return false;
1681
2251
  };
@@ -1689,6 +2259,7 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
1689
2259
  scope: context.scope,
1690
2260
  state: context.next,
1691
2261
  next: undefined,
2262
+ isKeepLazy: context.isKeepLazy,
1692
2263
  });
1693
2264
  };
1694
2265
  }
@@ -1713,13 +2284,20 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
1713
2284
  }
1714
2285
  case "Case": {
1715
2286
  const arms = expression.arms.map((arm) => ({
2287
+ source: arm.condition,
1716
2288
  condition: child(arm.condition),
1717
2289
  body: child(arm.body),
1718
2290
  }));
1719
2291
  const other = expression.other ? child(expression.other) : undefined;
1720
2292
  return (context) => {
1721
2293
  for (const arm of arms) {
1722
- if (expectBoolean(arm.condition(context), "a CASE guard")) return arm.body(context);
2294
+ const value = arm.condition(context);
2295
+ if (typeof value !== "boolean") {
2296
+ throw new TlaEvaluationError(
2297
+ `A non-boolean expression (${getKindString(value)}) was used as a condition of a CASE. ${describeNode(arm.source)}`,
2298
+ );
2299
+ }
2300
+ if (value) return arm.body(context);
1723
2301
  }
1724
2302
  if (other) return other(context);
1725
2303
  throw new TlaEvaluationError(
@@ -1782,33 +2360,27 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
1782
2360
  };
1783
2361
  case "FunctionApplication": {
1784
2362
  keepLazy(expression.function);
1785
- const evaluateFunction = child(expression.function);
2363
+ const evaluated = child(expression.function);
2364
+ const evaluateFunction = (context: Context) =>
2365
+ expectFunction(evaluated(toKeepLazyContext(context)), expression);
1786
2366
  const args = expression.args.map(child);
1787
- const describeNonFunction = getNonFunctionError(expression);
2367
+ const describeMissing = getMissingArgumentDescriber(environment.runtime.version);
1788
2368
  if (args.length === 1) {
1789
2369
  const argument = args[0];
1790
2370
  return (context) =>
1791
- applyFunction(
1792
- evaluateFunction(context),
1793
- argument(context),
1794
- undefined,
1795
- describeNonFunction,
1796
- );
2371
+ applyFunction(evaluateFunction(context), argument(context), describeMissing);
1797
2372
  }
1798
2373
  return (context) =>
1799
2374
  applyFunction(
1800
2375
  evaluateFunction(context),
1801
2376
  createTuple(args.map((arg) => arg(context))),
1802
- undefined,
1803
- describeNonFunction,
2377
+ describeMissing,
1804
2378
  );
1805
2379
  }
1806
2380
  case "FieldAccess": {
1807
2381
  const record = child(expression.record);
1808
- const field = expression.field;
1809
- const describeMissing = getFieldError(expression);
1810
- const describeNonRecord = getNonRecordError(expression);
1811
- return (context) => applyFunction(record(context), field, describeMissing, describeNonRecord);
2382
+ const select = getFieldSelector(expression);
2383
+ return (context) => select(record(context));
1812
2384
  }
1813
2385
  case "Product": {
1814
2386
  const factors = expression.factors.map(child);