tla-ts 0.0.2 → 0.0.3-dev.037ac3b

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 (63) hide show
  1. package/README.md +78 -12
  2. package/dist/index.cjs +1 -1
  3. package/dist/index.d.cts +60 -1
  4. package/dist/index.d.ts +60 -1
  5. package/dist/index.js +1 -1
  6. package/dist/parallel-worker.cjs +2 -2
  7. package/dist/parallel-worker.js +2 -2
  8. package/dist/parallel.cjs +1 -1
  9. package/dist/parallel.js +2 -2
  10. package/dist/run-cli.cjs +21 -2
  11. package/dist/run-cli.js +21 -2
  12. package/dist/transfer.cjs +27 -15
  13. package/dist/transfer.js +27 -15
  14. package/package.json +3 -1
  15. package/src/ast.ts +134 -4
  16. package/src/check.ts +280 -80
  17. package/src/cli-options.ts +64 -0
  18. package/src/codegen.ts +9 -19
  19. package/src/dependencies.ts +2 -2
  20. package/src/environment.ts +75 -16
  21. package/src/errors.ts +46 -3
  22. package/src/evaluate.ts +88 -143
  23. package/src/exit-codes.ts +21 -43
  24. package/src/fingerprints.ts +46 -11
  25. package/src/instances.ts +15 -14
  26. package/src/levels.ts +8 -8
  27. package/src/lexer.ts +11 -2
  28. package/src/live-check.ts +692 -0
  29. package/src/liveness.ts +54 -535
  30. package/src/obligation-action.ts +384 -0
  31. package/src/obligation-anon.ts +575 -0
  32. package/src/obligation-deref.ts +637 -0
  33. package/src/obligation-expression.ts +1060 -0
  34. package/src/obligation-format.ts +406 -0
  35. package/src/obligation-generate.ts +1074 -0
  36. package/src/obligation-levels.ts +329 -0
  37. package/src/obligation-module.ts +1042 -0
  38. package/src/obligation-printer.ts +889 -0
  39. package/src/obligation-proof.ts +76 -0
  40. package/src/obligation-source.ts +1084 -0
  41. package/src/obligation-tuples.ts +184 -0
  42. package/src/obligations.ts +316 -0
  43. package/src/parallel-worker.ts +166 -210
  44. package/src/parallel.ts +76 -35
  45. package/src/parser.ts +297 -53
  46. package/src/resolve.ts +16 -15
  47. package/src/run-cli.ts +353 -40
  48. package/src/runtime.ts +3 -1
  49. package/src/spec-description.ts +18 -6
  50. package/src/standard-levels.ts +3 -3
  51. package/src/standard-modules.ts +2 -7
  52. package/src/state-graph.ts +157 -0
  53. package/src/subexpressions.ts +10 -10
  54. package/src/successors.ts +77 -13
  55. package/src/symmetry.ts +14 -2
  56. package/src/tableau.ts +50 -23
  57. package/src/tlc-ext.ts +29 -12
  58. package/src/tlc-module.ts +9 -28
  59. package/src/tlc-order.ts +17 -3
  60. package/src/tlc-random.ts +9 -6
  61. package/src/tlc-summary.ts +20 -5
  62. package/src/transfer.ts +22 -1
  63. package/src/values.ts +118 -34
package/src/evaluate.ts CHANGED
@@ -1,14 +1,16 @@
1
- import type {
2
- Bound,
3
- BoundPattern,
4
- DecimalExpression,
5
- Definition,
6
- Expression,
7
- FunctionDefinition,
8
- NumberExpression,
9
- OperatorParam,
10
- RecordField,
11
- SourceRange,
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,
13
+ type SourceRange,
12
14
  } from "./ast";
13
15
  import { getKindString } from "./builtins";
14
16
  import { TlaEvaluationError } from "./errors";
@@ -34,11 +36,11 @@ import {
34
36
  getIntervalElements,
35
37
  getSequenceElements,
36
38
  getValueHash,
37
- isEnumerable,
38
39
  isFunctionValue,
39
40
  isOverriddenSet,
40
41
  isSameValue,
41
42
  markLambdaFunction,
43
+ isReducible,
42
44
  isSetValue,
43
45
  MAXIMUM_INTEGER,
44
46
  MINIMUM_INTEGER,
@@ -262,96 +264,6 @@ export const expectBoolean = (value: Value, description: string) => {
262
264
  return value;
263
265
  };
264
266
 
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
267
  export const getDefinition = (name: string, environment: Environment) =>
356
268
  environment.definitions.get(environment.substitutions.get(name) ?? name);
357
269
 
@@ -734,7 +646,9 @@ const compileArgumentBinder = (argument: Expression, environment: Environment):
734
646
  if (global === undefined) {
735
647
  return (context) => {
736
648
  const binding = lookupScope(context.scope, argument.name);
737
- return binding?.kind === "Value" ? binding : createThunk(argument, context);
649
+ return binding?.kind === "Value" || binding?.kind === "Thunk"
650
+ ? binding
651
+ : createThunk(argument, context);
738
652
  };
739
653
  }
740
654
  }
@@ -857,11 +771,7 @@ const evaluateLocalIdentifier = (name: string, expression: Expression, context:
857
771
  const global = findGlobalName(name, context.environment);
858
772
  if (global?.kind === "Variable") {
859
773
  const value = context.state?.[global.index];
860
- if (value === undefined) {
861
- throw new TlaEvaluationError(
862
- `The variable ${name} is not assigned at ${describeLocation(expression)}`,
863
- );
864
- }
774
+ if (value === undefined) throw createUnassignedError(name, expression);
865
775
  return value;
866
776
  }
867
777
  if (global?.kind === "Value") return global.value;
@@ -887,14 +797,29 @@ const IMPURE_BUILTINS = new Set([
887
797
  export const isImpureBuiltin = (name: string, environment: Environment) =>
888
798
  IMPURE_BUILTINS.has(name) || environment.builtins.get(name)?.isStateLevel === true;
889
799
 
890
- const impureDefinitions = new WeakMap<Definition, boolean>();
800
+ interface Impurity {
801
+ builtins: Set<string>;
802
+ definitions: WeakMap<Definition, boolean>;
803
+ }
804
+
805
+ const ANY_EFFECT: Impurity = { builtins: IMPURE_BUILTINS, definitions: new WeakMap() };
806
+
807
+ // An Assert that held holds again, so evaluating it twice looks the same as evaluating it once.
808
+ const REPEATED_EFFECT: Impurity = {
809
+ builtins: new Set([...IMPURE_BUILTINS].filter((name) => name !== "Assert")),
810
+ definitions: new WeakMap(),
811
+ };
891
812
 
892
813
  const isEvaluatedOnce = (definition: Definition, environment: Environment) =>
893
814
  definition.kind === "Operator" &&
894
815
  definition.params.length === 0 &&
895
816
  isConstantLevel(definition, environment);
896
817
 
897
- const callsImpureBuiltin = (expression: Expression, environment: Environment): boolean => {
818
+ const callsImpureBuiltin = (
819
+ expression: Expression,
820
+ environment: Environment,
821
+ impurity: Impurity,
822
+ ): boolean => {
898
823
  const name =
899
824
  expression.kind === "Identifier"
900
825
  ? expression.name
@@ -903,29 +828,35 @@ const callsImpureBuiltin = (expression: Expression, environment: Environment): b
903
828
  : undefined;
904
829
  if (name !== undefined && !isLocallyResolved(expression)) {
905
830
  const definition = getDefinition(name, environment);
906
- if (!definition && isImpureBuiltin(name, environment)) return true;
831
+ const isImpureCall =
832
+ impurity.builtins.has(name) || environment.builtins.get(name)?.isStateLevel === true;
833
+ if (!definition && isImpureCall) return true;
907
834
  if (
908
835
  definition &&
909
836
  !isEvaluatedOnce(definition, environment) &&
910
- isImpureDefinition(definition, environment)
837
+ isImpureDefinition(definition, environment, impurity)
911
838
  ) {
912
839
  return true;
913
840
  }
914
841
  }
915
- return getChildren(expression).some((child) => callsImpureBuiltin(child, environment));
842
+ return getChildren(expression).some((child) => callsImpureBuiltin(child, environment, impurity));
916
843
  };
917
844
 
918
845
  // TLC evaluates a constant definition without parameters once, so only other definitions pass
919
846
  // on the side effects and random choices of the builtins they call.
920
- const isImpureDefinition = (definition: Definition, environment: Environment): boolean => {
921
- const cached = impureDefinitions.get(definition);
847
+ const isImpureDefinition = (
848
+ definition: Definition,
849
+ environment: Environment,
850
+ impurity = ANY_EFFECT,
851
+ ): boolean => {
852
+ const cached = impurity.definitions.get(definition);
922
853
  if (cached !== undefined) return cached;
923
- impureDefinitions.set(definition, false);
854
+ impurity.definitions.set(definition, false);
924
855
  const isImpure =
925
- callsImpureBuiltin(definition.body, environment) ||
856
+ callsImpureBuiltin(definition.body, environment, impurity) ||
926
857
  (definition.kind === "Function" &&
927
- definition.bounds.some((bound) => callsImpureBuiltin(bound.set, environment)));
928
- impureDefinitions.set(definition, isImpure);
858
+ definition.bounds.some((bound) => callsImpureBuiltin(bound.set, environment, impurity)));
859
+ impurity.definitions.set(definition, isImpure);
929
860
  return isImpure;
930
861
  };
931
862
 
@@ -939,6 +870,12 @@ export const isImpure = (environment: Environment) =>
939
870
  isImpureDefinition(definition, environment),
940
871
  );
941
872
 
873
+ // Whether evaluating a definition again can show, such as by printing twice.
874
+ export const hasRepeatedEffects = (environment: Environment) =>
875
+ [...environment.definitions.values()].some((definition) =>
876
+ isImpureDefinition(definition, environment, REPEATED_EFFECT),
877
+ );
878
+
942
879
  const closedConstants = new WeakMap<Expression, boolean>();
943
880
 
944
881
  export const isClosedConstant = (expression: Expression, environment: Environment): boolean => {
@@ -1090,7 +1027,7 @@ export const getEvaluator = (expression: Expression, environment: Environment):
1090
1027
 
1091
1028
  const entryEvaluators = new WeakMap<Expression, Evaluator>();
1092
1029
 
1093
- const getEntryEvaluator = (expression: Expression, environment: Environment) => {
1030
+ export const getEntryEvaluator = (expression: Expression, environment: Environment) => {
1094
1031
  const cached = entryEvaluators.get(expression);
1095
1032
  if (cached) return cached;
1096
1033
  const evaluator =
@@ -1114,11 +1051,7 @@ const compileIdentifier = (
1114
1051
  const index = global.index;
1115
1052
  return (context) => {
1116
1053
  const value = context.state?.[index];
1117
- if (value === undefined) {
1118
- throw new TlaEvaluationError(
1119
- `The variable ${name} is not assigned at ${describeLocation(expression)}`,
1120
- );
1121
- }
1054
+ if (value === undefined) throw createUnassignedError(name, expression);
1122
1055
  return value;
1123
1056
  };
1124
1057
  }
@@ -1487,7 +1420,13 @@ const compileFunctionConstruction = (
1487
1420
  const set = getEvaluator(bound.set, environment);
1488
1421
  return (context) => {
1489
1422
  const domain = isSingleName ? set(context) : getBoundsDomain(bounds, context);
1490
- if (expression.isRecursive || isKeptLazy || !isEnumerable(domain)) {
1423
+ // TLC builds the function only when it reduces every domain, and evaluates the body lazily
1424
+ // otherwise.
1425
+ const domains =
1426
+ typeof domain === "object" && domain.kind === "ProductSet" && bounds.length > 1
1427
+ ? domain.factors
1428
+ : [domain];
1429
+ if (expression.isRecursive || isKeptLazy || !domains.every(isReducible)) {
1491
1430
  const functionValue = createLazyFunction(
1492
1431
  domain,
1493
1432
  (argument) => body(withScope(context, bindArgument(bounds, context.scope, argument))),
@@ -1581,10 +1520,7 @@ const compileSetComprehension = (
1581
1520
  predicate(withScope(context, bindPattern(context.scope, pattern, element))),
1582
1521
  "a set filter predicate",
1583
1522
  );
1584
- const isReducible =
1585
- typeof base === "object" &&
1586
- (base.kind === "Set" || base.kind === "MixedSet" || base.kind === "Interval");
1587
- if (!isReducible) {
1523
+ if (!isReducible(base)) {
1588
1524
  if (isSetValue(base)) return { kind: "FilteredSet", base, test };
1589
1525
  throw new TlaEvaluationError(
1590
1526
  `TLC encountered a non-enumerable quantifier bound ${formatValue(base)} at ${describeLocation(expression.bound.set)}`,
@@ -1630,11 +1566,24 @@ const compileSetComprehension = (
1630
1566
  };
1631
1567
  };
1632
1568
 
1633
- const compileRecord = (recordFields: RecordField[], environment: Environment): Evaluator => {
1634
- const fields = [...recordFields].sort((left, right) => compareValues(left.name, right.name));
1635
- const hasDuplicates = fields.some(
1636
- (field, index) => index > 0 && fields[index - 1].name === field.name,
1569
+ // TLC orders a record's fields by name.
1570
+ export const getSortedFields = (fields: RecordField[]) =>
1571
+ [...fields].sort((left, right) => compareValues(left.name, right.name));
1572
+
1573
+ export const hasDuplicateFields = (sortedFields: RecordField[]) =>
1574
+ sortedFields.some((field, index) => index > 0 && sortedFields[index - 1].name === field.name);
1575
+
1576
+ export const createUnassignedError = (name: string, expression: Expression) =>
1577
+ new TlaEvaluationError(`The variable ${name} is not assigned at ${describeLocation(expression)}`);
1578
+
1579
+ export const createPrimeOutsideActionError = (expression: Expression) =>
1580
+ new TlaEvaluationError(
1581
+ `A primed expression appears outside an action at ${describeLocation(expression)}`,
1637
1582
  );
1583
+
1584
+ const compileRecord = (recordFields: RecordField[], environment: Environment): Evaluator => {
1585
+ const fields = getSortedFields(recordFields);
1586
+ const hasDuplicates = hasDuplicateFields(fields);
1638
1587
  const values = fields.map((field) => getEvaluator(field.value, environment));
1639
1588
  if (hasDuplicates) {
1640
1589
  return (context) =>
@@ -1712,11 +1661,7 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
1712
1661
  case "Prime": {
1713
1662
  const inner = child(expression.expression);
1714
1663
  return (context) => {
1715
- if (!context.next) {
1716
- throw new TlaEvaluationError(
1717
- `A primed expression appears outside an action at ${describeLocation(expression)}`,
1718
- );
1719
- }
1664
+ if (!context.next) throw createPrimeOutsideActionError(expression);
1720
1665
  return inner({
1721
1666
  environment: context.environment,
1722
1667
  scope: context.scope,
@@ -1755,7 +1700,9 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
1755
1700
  if (expectBoolean(arm.condition(context), "a CASE guard")) return arm.body(context);
1756
1701
  }
1757
1702
  if (other) return other(context);
1758
- throw new TlaEvaluationError(`No CASE guard is true at ${describeLocation(expression)}`);
1703
+ throw new TlaEvaluationError(
1704
+ `Attempted to evaluate a CASE with no conditions true.\n${describeRange(expression)}`,
1705
+ );
1759
1706
  };
1760
1707
  }
1761
1708
  case "Let": {
@@ -1794,9 +1741,7 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
1794
1741
  case "Record":
1795
1742
  return compileRecord(expression.fields, environment);
1796
1743
  case "RecordSet": {
1797
- const fields = [...expression.fields].sort((left, right) =>
1798
- compareValues(left.name, right.name),
1799
- );
1744
+ const fields = getSortedFields(expression.fields);
1800
1745
  const names = fields.map((field) => field.name);
1801
1746
  const sets = fields.map((field) => child(field.value));
1802
1747
  return (context) => ({ kind: "RecordSet", names, sets: sets.map((set) => set(context)) });
package/src/exit-codes.ts CHANGED
@@ -1,4 +1,4 @@
1
- import type { LivenessChecker } from "./liveness";
1
+ import type { LivenessChecker } from "./live-check";
2
2
 
3
3
  // TLC's exit statuses, from EC.ExitStatus.
4
4
  export const EXIT_STATUS = {
@@ -17,12 +17,6 @@ export const EXIT_STATUS = {
17
17
  } as const;
18
18
 
19
19
  const exitCodes = new WeakMap<Error, number>();
20
- const moduleExitCodes = new WeakMap<Error, number>();
21
- const phase = { isNextState: false };
22
-
23
- export const setNextStatePhase = (isNextState: boolean) => {
24
- phase.isNextState = isNextState;
25
- };
26
20
 
27
21
  // The innermost site that knows TLC's exit status for an error sets it first and wins.
28
22
  export const setExitCode = <Thrown>(error: Thrown, code: number) => {
@@ -30,46 +24,30 @@ export const setExitCode = <Thrown>(error: Thrown, code: number) => {
30
24
  return error;
31
25
  };
32
26
 
33
- // TLC exits with the code of an exception from a standard module's Java code only when the exception
34
- // escapes the computation of next states. In every other phase, the phase decides the code.
35
- export const setModuleExitCode = (error: Error, code: number) => {
36
- if (phase.isNextState) moduleExitCodes.set(error, code);
37
- };
38
-
39
- export const getExitCode = (error: Error) => exitCodes.get(error) ?? moduleExitCodes.get(error);
27
+ export const getExitCode = (error: Error) => exitCodes.get(error);
40
28
 
41
29
  // TLC exits with 255 when it fails to process or evaluate a liveness property, in any phase.
42
- export const withLivenessExitCode = (
43
- create: () => LivenessChecker | undefined,
44
- ): LivenessChecker | undefined => {
30
+ const withErrorExitCode = <Result>(run: () => Result) => {
45
31
  try {
46
- const checker = create();
47
- return (
48
- checker && {
49
- addInitialState: (index, state) => {
50
- try {
51
- checker.addInitialState(index, state);
52
- } catch (error) {
53
- throw setExitCode(error, EXIT_STATUS.error);
54
- }
55
- },
56
- addState: (index, state, successors) => {
57
- try {
58
- return checker.addState(index, state, successors);
59
- } catch (error) {
60
- throw setExitCode(error, EXIT_STATUS.error);
61
- }
62
- },
63
- findViolation: () => {
64
- try {
65
- return checker.findViolation();
66
- } catch (error) {
67
- throw setExitCode(error, EXIT_STATUS.error);
68
- }
69
- },
70
- }
71
- );
32
+ return run();
72
33
  } catch (error) {
73
34
  throw setExitCode(error, EXIT_STATUS.error);
74
35
  }
75
36
  };
37
+
38
+ export const withLivenessExitCode = (
39
+ create: () => LivenessChecker | undefined,
40
+ ): LivenessChecker | undefined => {
41
+ const checker = withErrorExitCode(create);
42
+ return (
43
+ checker && {
44
+ addInitialState: (index, state) =>
45
+ withErrorExitCode(() => checker.addInitialState(index, state)),
46
+ addState: (index, state, successors) =>
47
+ withErrorExitCode(() => checker.addState(index, state, successors)),
48
+ findViolation: () => withErrorExitCode(() => checker.findViolation()),
49
+ getViolatedProperties: (path, cycleStart) =>
50
+ withErrorExitCode(() => checker.getViolatedProperties(path, cycleStart)),
51
+ }
52
+ );
53
+ };
@@ -1,12 +1,10 @@
1
1
  import { getValueFingerprint, getValueHash, type Value } from "./values";
2
2
 
3
3
  const EMPTY = 0;
4
- const TOMBSTONE = 1;
5
4
  const INITIAL_CAPACITY = 1 << 12;
6
5
 
7
6
  interface FingerprintTable {
8
7
  insert: (first: number, second: number) => boolean;
9
- remove: (first: number, second: number) => void;
10
8
  }
11
9
 
12
10
  const mix = (hash: number) => {
@@ -26,15 +24,13 @@ export const writeStateFingerprint = (state: Value[], fingerprint: Int32Array) =
26
24
  fingerprint[1] = mix(second);
27
25
  };
28
26
 
29
- export const getFingerprintOwner = (second: number, count: number) => (second >>> 0) % count;
30
-
31
27
  export const createFingerprintTable = (): FingerprintTable => {
32
28
  const table = { slots: new Int32Array(INITIAL_CAPACITY * 2), used: 0 };
33
29
  const findSlot = (slots: Int32Array, first: number, second: number) => {
34
30
  const mask = slots.length / 2 - 1;
35
31
  for (let index = first & mask; ; index = (index + 1) & mask) {
36
32
  const stored = slots[index * 2];
37
- if (stored === EMPTY && slots[index * 2 + 1] === EMPTY) return index;
33
+ if (stored === EMPTY) return index;
38
34
  if (stored === first && slots[index * 2 + 1] === second) return index;
39
35
  }
40
36
  };
@@ -59,11 +55,50 @@ export const createFingerprintTable = (): FingerprintTable => {
59
55
  table.used++;
60
56
  return true;
61
57
  },
62
- remove: (first, second) => {
63
- const slot = findSlot(table.slots, first, second);
64
- if (table.slots[slot * 2] !== first) return;
65
- table.slots[slot * 2] = EMPTY;
66
- table.slots[slot * 2 + 1] = TOMBSTONE;
67
- },
68
58
  };
69
59
  };
60
+
61
+ // Workers share one table of 64-bit fingerprints. The first word is never 0, so 0 marks an empty slot.
62
+ export interface SharedFingerprints {
63
+ slots: BigInt64Array;
64
+ used: Int32Array;
65
+ }
66
+
67
+ const INITIAL_SHARED_CAPACITY = 1 << 10;
68
+
69
+ const insertSharedKey = (slots: BigInt64Array, key: bigint) => {
70
+ const mask = slots.length - 1;
71
+ for (let index = Number(key >> 32n) & mask; ; index = (index + 1) & mask) {
72
+ const stored = Atomics.load(slots, index);
73
+ if (stored === key) return false;
74
+ if (stored !== 0n) continue;
75
+ const previous = Atomics.compareExchange(slots, index, 0n, key);
76
+ if (previous === 0n) return true;
77
+ if (previous === key) return false;
78
+ }
79
+ };
80
+
81
+ export const createSharedFingerprints = (): SharedFingerprints => ({
82
+ slots: new BigInt64Array(new SharedArrayBuffer(INITIAL_SHARED_CAPACITY * 8)),
83
+ used: new Int32Array(new SharedArrayBuffer(4)),
84
+ });
85
+
86
+ export const insertSharedFingerprint = (
87
+ table: SharedFingerprints,
88
+ first: number,
89
+ second: number,
90
+ ) => {
91
+ const key = BigInt.asIntN(64, (BigInt(first) << 32n) | BigInt(second >>> 0));
92
+ if (!insertSharedKey(table.slots, key)) return false;
93
+ Atomics.add(table.used, 0, 1);
94
+ return true;
95
+ };
96
+
97
+ export const isSharedFingerprintsFull = (table: SharedFingerprints) =>
98
+ Atomics.load(table.used, 0) * 2 >= table.slots.length;
99
+
100
+ export const growSharedFingerprints = (table: SharedFingerprints): SharedFingerprints => {
101
+ const slots = new BigInt64Array(new SharedArrayBuffer(table.slots.byteLength * 2));
102
+ for (const key of table.slots) if (key !== 0n) insertSharedKey(slots, key);
103
+ return { slots, used: table.used };
104
+ };
package/src/instances.ts CHANGED
@@ -1,16 +1,17 @@
1
- import type {
2
- Bound,
3
- BoundPattern,
4
- Definition,
5
- Expression,
6
- Instance,
7
- Module,
8
- OperatorParam,
9
- SourceLocation,
10
- Theorem,
1
+ import {
2
+ getChildren,
3
+ isLocallyResolved,
4
+ type Bound,
5
+ type BoundPattern,
6
+ type Definition,
7
+ type Expression,
8
+ type Instance,
9
+ type Module,
10
+ type OperatorParam,
11
+ type SourceLocation,
12
+ type Theorem,
11
13
  } from "./ast";
12
14
  import { TlaSyntaxError } from "./errors";
13
- import { getChildren, isLocallyResolved } from "./evaluate";
14
15
  import { getArity, getBoundNames, getPatternNames, isBefore } from "./resolve";
15
16
 
16
17
  export const substitutedExpressions = new WeakSet<Expression>();
@@ -218,7 +219,7 @@ interface Instantiation {
218
219
  variables: Set<string>;
219
220
  getDefinition: (key: string) => Definition | undefined;
220
221
  isParameterized: (key: string) => boolean;
221
- addDefinition: (name: string, create: (key: string) => Definition) => string;
222
+ addDefinition: (source: string, name: string, create: (key: string) => Definition) => string;
222
223
  createName: (name: string) => string;
223
224
  }
224
225
 
@@ -639,7 +640,7 @@ const copyDefinition = (rewrite: Rewrite, key: string): string => {
639
640
  const instantiation = rewrite.instantiation;
640
641
  const definition = instantiation.getDefinition(key);
641
642
  if (!definition) return key;
642
- return instantiation.addDefinition(definition.name, (copyKey) => {
643
+ return instantiation.addDefinition(key, definition.name, (copyKey) => {
643
644
  rewrite.copies.set(key, copyKey);
644
645
  const rename = createRenamer(rewrite);
645
646
  const mapped = renameParams(
@@ -678,7 +679,7 @@ export const createInstantiation = (instantiation: Instantiation) => {
678
679
  if (copy !== undefined) return copy;
679
680
  const definition = instantiation.getDefinition(key);
680
681
  if (!definition) return key;
681
- return instantiation.addDefinition(definition.name, () =>
682
+ return instantiation.addDefinition(key, definition.name, () =>
682
683
  withInstanceParams(definition, instantiation.params, definition.location),
683
684
  );
684
685
  },
package/src/levels.ts CHANGED
@@ -1,13 +1,13 @@
1
- import type {
2
- AssumeProve,
3
- Definition,
4
- Expression,
5
- Module,
6
- OperatorParam,
7
- SourceLocation,
1
+ import {
2
+ getChildren,
3
+ type AssumeProve,
4
+ type Definition,
5
+ type Expression,
6
+ type Module,
7
+ type OperatorParam,
8
+ type SourceLocation,
8
9
  } from "./ast";
9
10
  import { TlaSyntaxError } from "./errors";
10
- import { getChildren } from "./evaluate";
11
11
  import { mapChildren } from "./instances";
12
12
  import { getBoundNames, getPatternNames } from "./resolve";
13
13
  import { STANDARD_LEVELS } from "./standard-levels";
package/src/lexer.ts CHANGED
@@ -345,6 +345,8 @@ export const tokenize = (source: string): Token[] => {
345
345
  if (!headerMatch)
346
346
  throw new TlaSyntaxError("Expected a module header such as ---- MODULE Name ----");
347
347
  const tokens: Token[] = [];
348
+ // Each name is one string object, so looking a name up in a scope compares pointers.
349
+ const names = new Map<string, string>();
348
350
  const prefixLines = source.slice(0, headerMatch.index).split("\n");
349
351
  const cursor = {
350
352
  index: headerMatch.index,
@@ -380,7 +382,12 @@ export const tokenize = (source: string): Token[] => {
380
382
  }
381
383
  };
382
384
  const createError = (message: string) =>
383
- new TlaSyntaxError(`${message} at line ${cursor.line}, column ${getColumn()}`);
385
+ new TlaSyntaxError(`${message} at line ${cursor.line}, column ${getColumn()}`, undefined, {
386
+ reason: message,
387
+ line: cursor.line,
388
+ column: getColumn(),
389
+ isEnd: cursor.index >= source.length,
390
+ });
384
391
 
385
392
  while (cursor.index < source.length) {
386
393
  const character = source[cursor.index];
@@ -476,7 +483,9 @@ export const tokenize = (source: string): Token[] => {
476
483
  pushToken("Keyword", word.slice(0, 3), 3);
477
484
  continue;
478
485
  }
479
- pushToken(KEYWORDS.has(word) ? "Keyword" : "Identifier", word, word.length);
486
+ const name = names.get(word) ?? word;
487
+ names.set(name, name);
488
+ pushToken(KEYWORDS.has(word) ? "Keyword" : "Identifier", name, word.length);
480
489
  continue;
481
490
  }
482
491
  const stepLength = matchStep(source, cursor.index);