tla-ts 0.0.3-dev.5e6ab4d → 0.0.3-dev.660addc

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.
@@ -1,12 +1,13 @@
1
- import type {
2
- Assumption,
3
- Declaration,
4
- Definition,
5
- Expression,
6
- Instance,
7
- Module,
8
- OperatorParam,
9
- SourceLocation,
1
+ import {
2
+ getChildren,
3
+ type Assumption,
4
+ type Declaration,
5
+ type Definition,
6
+ type Expression,
7
+ type Instance,
8
+ type Module,
9
+ type OperatorParam,
10
+ type SourceLocation,
10
11
  } from "./ast";
11
12
  import { BUNDLED_MODULES } from "./bundled-modules";
12
13
  import type { ConfigValue, ModelConfig } from "./config";
@@ -16,8 +17,8 @@ import { EXIT_STATUS, setExitCode } from "./exit-codes";
16
17
  import {
17
18
  createBigNumberError,
18
19
  createRealNumberError,
19
- getChildren,
20
- isConstantLevel,
20
+ evaluate,
21
+ getDefinition,
21
22
  isTlcInteger,
22
23
  type Builtin,
23
24
  type Environment,
@@ -44,7 +45,7 @@ import {
44
45
  import { createRuntime } from "./runtime";
45
46
  import { CORE_OPERATORS, getStandardModule, STANDARD_DEPENDENCIES } from "./standard-modules";
46
47
  import { resolveInstanceSubexpressions, resolveModuleSubexpressions } from "./subexpressions";
47
- import { checkModuleLevels } from "./levels";
48
+ import { checkModuleLevels, createLevelAnalyzer } from "./levels";
48
49
  import { checkInstances, type InstanceCheck } from "./substitution-levels";
49
50
  import {
50
51
  checkInteger,
@@ -212,6 +213,8 @@ export const createEnvironment = (
212
213
  const root = parseModule(options.source);
213
214
  const definitions = new Map<string, Definition>();
214
215
  const parameterized = new Map<string, boolean>();
216
+ // The definition each instance copy came from, and the instance parameters the copy adds.
217
+ const copySources = new Map<string, { source: string; prefix: number }>();
215
218
  const builtins = new Map<string, Builtin>(
216
219
  CORE_OPERATORS.map((operator) => [operator.name, operator]),
217
220
  );
@@ -379,10 +382,11 @@ export const createEnvironment = (
379
382
  variables: new Set(linked.variables),
380
383
  getDefinition: (key) => definitions.get(key),
381
384
  isParameterized: (key) => parameterized.get(key) === true,
382
- addDefinition: (name, create) => {
385
+ addDefinition: (source, name, create) => {
383
386
  const key = createName(`${name}@${module.name}`);
384
387
  definitions.set(key, create(key));
385
388
  parameterized.set(key, !isParameterFree);
389
+ copySources.set(key, { source, prefix: instance.params.length });
386
390
  return key;
387
391
  },
388
392
  createName,
@@ -544,7 +548,7 @@ export const createEnvironment = (
544
548
  variables: new Set(linked.variables),
545
549
  getDefinition: (key) => definitions.get(key),
546
550
  isParameterized: (key) => parameterized.get(key) === true,
547
- addDefinition: (name, create) => {
551
+ addDefinition: (_source, name, create) => {
548
552
  const key = `${name}${KEY_SEPARATOR}${instance.module}${suffix}.${copies.length}`;
549
553
  const definition = create(key);
550
554
  copies.push(
@@ -872,6 +876,38 @@ export const createEnvironment = (
872
876
  );
873
877
  }
874
878
  });
879
+ // TLC sets a module-scoped entry on the body of the module's definition, which every instance of
880
+ // the module shares.
881
+ const scopedKeys = new Set(
882
+ [...config.constants, ...config.substitutions]
883
+ .filter((item) => item.module !== undefined)
884
+ .flatMap(getScopedKeys),
885
+ );
886
+ const getOverride = (
887
+ key: string,
888
+ prefix: number,
889
+ ): { key: string; prefix: number } | undefined => {
890
+ if (scopedKeys.has(key)) return { key, prefix };
891
+ const copy = copySources.get(key);
892
+ return copy && getOverride(copy.source, prefix + copy.prefix);
893
+ };
894
+ copySources.forEach((copy, key) => {
895
+ const override = getOverride(copy.source, copy.prefix);
896
+ const definition = definitions.get(key);
897
+ if (!override || !definition) return;
898
+ const params = definition.kind === "Operator" ? definition.params : [];
899
+ const alias = createLocalAlias(
900
+ key,
901
+ override.key,
902
+ params,
903
+ params.slice(override.prefix),
904
+ definition.location,
905
+ );
906
+ definitions.set(key, alias);
907
+ linkedRoot.visible.forEach((symbol, name) => {
908
+ if (symbol.key === key && name !== key) definitions.set(name, alias);
909
+ });
910
+ });
875
911
  declaredConstants.forEach((name) => {
876
912
  if (!constants.has(name) && !substitutions.has(name) && !operatorKeys.has(name)) {
877
913
  throw new TlaConfigError(`The constant ${name} is not assigned a value by the configuration`);
@@ -907,18 +943,41 @@ export const createEnvironment = (
907
943
  getDefinition: (symbol) => definitions.get(linked.visible.get(symbol)?.key ?? symbol),
908
944
  };
909
945
  });
946
+ // TLC evaluates a substitute at startup and rejects it only when that fails and the level bound it
947
+ // computes is above constant. The bound counts the operators that TLC's Java code overrides with
948
+ // a minimum level as state-level, so the analyzer takes them for variables.
949
+ const analyzer = createLevelAnalyzer({
950
+ constants: new Set(constants.keys()),
951
+ variables: new Set([
952
+ ...variables,
953
+ ...["TLCGet", "Trace", "CounterExample"].filter((name) => builtins.has(name)),
954
+ ]),
955
+ getDefinition: (name) => getDefinition(name, environment),
956
+ });
957
+ const isEvaluable = (body: Expression) => {
958
+ try {
959
+ evaluate(body, { environment, scope: undefined, state: undefined, next: undefined });
960
+ return true;
961
+ } catch (error) {
962
+ if (error instanceof TlaEvaluationError) return false;
963
+ throw error;
964
+ }
965
+ };
910
966
  substitutions.forEach((target, name) => {
911
967
  const definition = definitions.get(target);
912
968
  if (
913
969
  declaredConstants.includes(name) &&
914
- definition &&
915
- !isConstantLevel(definition, environment)
970
+ definition?.kind === "Operator" &&
971
+ definition.params.length === 0 &&
972
+ analyzer.analyzeDefinition(definition, new Map()).level > 0 &&
973
+ !isEvaluable(definition.body)
916
974
  ) {
917
975
  throw new TlaConfigError(
918
976
  `The configuration file substitutes constant ${name} with non-constant ${target}`,
919
977
  );
920
978
  }
921
979
  });
980
+ runtime.isStarted = true;
922
981
  return {
923
982
  environment,
924
983
  assumptions,
package/src/errors.ts CHANGED
@@ -1,4 +1,9 @@
1
- import { EXIT_STATUS, getExitCode, setModuleExitCode } from "./exit-codes";
1
+ import { EXIT_STATUS, getExitCode } from "./exit-codes";
2
+
3
+ // How TLC reports a RuntimeException it did not expect, such as one raised while computing next
4
+ // states.
5
+ export const UNEXPECTED_EXCEPTION =
6
+ "TLC threw an unexpected exception.\nThis was probably caused by an error in the spec or model.\nSee the User Output or TLC Console for clues to what happened.\nThe exception was a java.lang.RuntimeException\n: ";
2
7
 
3
8
  export class TlaError extends Error {
4
9
  constructor(message: string, cause?: unknown) {
@@ -41,10 +46,12 @@ export class TlaEvaluationError extends TlaError {
41
46
  // An evaluation error that TLC raises as an EvalException from a standard module's Java code. It
42
47
  // keeps the name TlaEvaluationError, and index.ts doesn't export it.
43
48
  export class TlaModuleError extends TlaEvaluationError {
49
+ exitCode: number;
50
+
44
51
  constructor(message: string, exitCode: number = EXIT_STATUS.error) {
45
52
  super(message);
46
53
  this.name = "TlaEvaluationError";
47
- setModuleExitCode(this, exitCode);
54
+ this.exitCode = exitCode;
48
55
  }
49
56
  }
50
57
 
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";
@@ -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
 
@@ -859,11 +771,7 @@ const evaluateLocalIdentifier = (name: string, expression: Expression, context:
859
771
  const global = findGlobalName(name, context.environment);
860
772
  if (global?.kind === "Variable") {
861
773
  const value = context.state?.[global.index];
862
- if (value === undefined) {
863
- throw new TlaEvaluationError(
864
- `The variable ${name} is not assigned at ${describeLocation(expression)}`,
865
- );
866
- }
774
+ if (value === undefined) throw createUnassignedError(name, expression);
867
775
  return value;
868
776
  }
869
777
  if (global?.kind === "Value") return global.value;
@@ -889,14 +797,29 @@ const IMPURE_BUILTINS = new Set([
889
797
  export const isImpureBuiltin = (name: string, environment: Environment) =>
890
798
  IMPURE_BUILTINS.has(name) || environment.builtins.get(name)?.isStateLevel === true;
891
799
 
892
- 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
+ };
893
812
 
894
813
  const isEvaluatedOnce = (definition: Definition, environment: Environment) =>
895
814
  definition.kind === "Operator" &&
896
815
  definition.params.length === 0 &&
897
816
  isConstantLevel(definition, environment);
898
817
 
899
- const callsImpureBuiltin = (expression: Expression, environment: Environment): boolean => {
818
+ const callsImpureBuiltin = (
819
+ expression: Expression,
820
+ environment: Environment,
821
+ impurity: Impurity,
822
+ ): boolean => {
900
823
  const name =
901
824
  expression.kind === "Identifier"
902
825
  ? expression.name
@@ -905,29 +828,35 @@ const callsImpureBuiltin = (expression: Expression, environment: Environment): b
905
828
  : undefined;
906
829
  if (name !== undefined && !isLocallyResolved(expression)) {
907
830
  const definition = getDefinition(name, environment);
908
- 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;
909
834
  if (
910
835
  definition &&
911
836
  !isEvaluatedOnce(definition, environment) &&
912
- isImpureDefinition(definition, environment)
837
+ isImpureDefinition(definition, environment, impurity)
913
838
  ) {
914
839
  return true;
915
840
  }
916
841
  }
917
- return getChildren(expression).some((child) => callsImpureBuiltin(child, environment));
842
+ return getChildren(expression).some((child) => callsImpureBuiltin(child, environment, impurity));
918
843
  };
919
844
 
920
845
  // TLC evaluates a constant definition without parameters once, so only other definitions pass
921
846
  // on the side effects and random choices of the builtins they call.
922
- const isImpureDefinition = (definition: Definition, environment: Environment): boolean => {
923
- 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);
924
853
  if (cached !== undefined) return cached;
925
- impureDefinitions.set(definition, false);
854
+ impurity.definitions.set(definition, false);
926
855
  const isImpure =
927
- callsImpureBuiltin(definition.body, environment) ||
856
+ callsImpureBuiltin(definition.body, environment, impurity) ||
928
857
  (definition.kind === "Function" &&
929
- definition.bounds.some((bound) => callsImpureBuiltin(bound.set, environment)));
930
- impureDefinitions.set(definition, isImpure);
858
+ definition.bounds.some((bound) => callsImpureBuiltin(bound.set, environment, impurity)));
859
+ impurity.definitions.set(definition, isImpure);
931
860
  return isImpure;
932
861
  };
933
862
 
@@ -941,6 +870,12 @@ export const isImpure = (environment: Environment) =>
941
870
  isImpureDefinition(definition, environment),
942
871
  );
943
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
+
944
879
  const closedConstants = new WeakMap<Expression, boolean>();
945
880
 
946
881
  export const isClosedConstant = (expression: Expression, environment: Environment): boolean => {
@@ -1116,11 +1051,7 @@ const compileIdentifier = (
1116
1051
  const index = global.index;
1117
1052
  return (context) => {
1118
1053
  const value = context.state?.[index];
1119
- if (value === undefined) {
1120
- throw new TlaEvaluationError(
1121
- `The variable ${name} is not assigned at ${describeLocation(expression)}`,
1122
- );
1123
- }
1054
+ if (value === undefined) throw createUnassignedError(name, expression);
1124
1055
  return value;
1125
1056
  };
1126
1057
  }
@@ -1632,11 +1563,24 @@ const compileSetComprehension = (
1632
1563
  };
1633
1564
  };
1634
1565
 
1635
- const compileRecord = (recordFields: RecordField[], environment: Environment): Evaluator => {
1636
- const fields = [...recordFields].sort((left, right) => compareValues(left.name, right.name));
1637
- const hasDuplicates = fields.some(
1638
- (field, index) => index > 0 && fields[index - 1].name === field.name,
1566
+ // TLC orders a record's fields by name.
1567
+ export const getSortedFields = (fields: RecordField[]) =>
1568
+ [...fields].sort((left, right) => compareValues(left.name, right.name));
1569
+
1570
+ export const hasDuplicateFields = (sortedFields: RecordField[]) =>
1571
+ sortedFields.some((field, index) => index > 0 && sortedFields[index - 1].name === field.name);
1572
+
1573
+ export const createUnassignedError = (name: string, expression: Expression) =>
1574
+ new TlaEvaluationError(`The variable ${name} is not assigned at ${describeLocation(expression)}`);
1575
+
1576
+ export const createPrimeOutsideActionError = (expression: Expression) =>
1577
+ new TlaEvaluationError(
1578
+ `A primed expression appears outside an action at ${describeLocation(expression)}`,
1639
1579
  );
1580
+
1581
+ const compileRecord = (recordFields: RecordField[], environment: Environment): Evaluator => {
1582
+ const fields = getSortedFields(recordFields);
1583
+ const hasDuplicates = hasDuplicateFields(fields);
1640
1584
  const values = fields.map((field) => getEvaluator(field.value, environment));
1641
1585
  if (hasDuplicates) {
1642
1586
  return (context) =>
@@ -1714,11 +1658,7 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
1714
1658
  case "Prime": {
1715
1659
  const inner = child(expression.expression);
1716
1660
  return (context) => {
1717
- if (!context.next) {
1718
- throw new TlaEvaluationError(
1719
- `A primed expression appears outside an action at ${describeLocation(expression)}`,
1720
- );
1721
- }
1661
+ if (!context.next) throw createPrimeOutsideActionError(expression);
1722
1662
  return inner({
1723
1663
  environment: context.environment,
1724
1664
  scope: context.scope,
@@ -1757,7 +1697,9 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
1757
1697
  if (expectBoolean(arm.condition(context), "a CASE guard")) return arm.body(context);
1758
1698
  }
1759
1699
  if (other) return other(context);
1760
- throw new TlaEvaluationError(`No CASE guard is true at ${describeLocation(expression)}`);
1700
+ throw new TlaEvaluationError(
1701
+ `Attempted to evaluate a CASE with no conditions true.\n${describeRange(expression)}`,
1702
+ );
1761
1703
  };
1762
1704
  }
1763
1705
  case "Let": {
@@ -1796,9 +1738,7 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
1796
1738
  case "Record":
1797
1739
  return compileRecord(expression.fields, environment);
1798
1740
  case "RecordSet": {
1799
- const fields = [...expression.fields].sort((left, right) =>
1800
- compareValues(left.name, right.name),
1801
- );
1741
+ const fields = getSortedFields(expression.fields);
1802
1742
  const names = fields.map((field) => field.name);
1803
1743
  const sets = fields.map((field) => child(field.value));
1804
1744
  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
+ };
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";