tla-ts 0.0.3-dev.4c8c06c → 0.0.3-dev.4fdd845

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 (84) hide show
  1. package/README.md +16 -2
  2. package/dist/cli.cjs +1 -1
  3. package/dist/cli.js +1 -1
  4. package/dist/index.cjs +1 -1
  5. package/dist/index.d.cts +157 -8
  6. package/dist/index.d.ts +157 -8
  7. package/dist/index.js +1 -1
  8. package/dist/parallel-worker.cjs +1 -1
  9. package/dist/parallel-worker.js +2 -2
  10. package/dist/parallel.cjs +1 -1
  11. package/dist/parallel.js +2 -2
  12. package/dist/run-cli.cjs +1351 -19
  13. package/dist/run-cli.js +1351 -19
  14. package/dist/transfer.cjs +86 -16
  15. package/dist/transfer.js +86 -16
  16. package/package.json +5 -1
  17. package/src/ast.ts +142 -6
  18. package/src/bags.ts +4 -7
  19. package/src/builtins.ts +29 -11
  20. package/src/bundled-modules.ts +3 -3
  21. package/src/canonical.ts +4 -3
  22. package/src/check.ts +1539 -235
  23. package/src/cli-options.ts +11 -5
  24. package/src/cli.ts +8 -1
  25. package/src/codegen.ts +77 -37
  26. package/src/config.ts +252 -179
  27. package/src/dependencies.ts +2 -2
  28. package/src/environment.ts +518 -137
  29. package/src/errors.ts +224 -3
  30. package/src/evaluate.ts +796 -246
  31. package/src/exit-codes.ts +22 -43
  32. package/src/index.ts +1 -0
  33. package/src/instances.ts +19 -16
  34. package/src/java-overrides.ts +104 -25
  35. package/src/levels.ts +191 -45
  36. package/src/lexer.ts +32 -4
  37. package/src/live-check.ts +828 -0
  38. package/src/liveness.ts +218 -572
  39. package/src/obligation-expression.ts +2 -2
  40. package/src/obligation-source.ts +2 -0
  41. package/src/parallel-worker.ts +13 -4
  42. package/src/parallel.ts +73 -6
  43. package/src/parser.ts +447 -128
  44. package/src/pcal-ast.ts +770 -0
  45. package/src/pcal-parse.ts +1523 -0
  46. package/src/pcal-tokenize.ts +516 -0
  47. package/src/pcal-translate.ts +1230 -0
  48. package/src/pcal-validate.ts +454 -0
  49. package/src/randomization.ts +24 -7
  50. package/src/resolve.ts +1380 -420
  51. package/src/run-cli.ts +1200 -143
  52. package/src/runtime.ts +19 -1
  53. package/src/sany-builtins.ts +147 -0
  54. package/src/sany-generator.ts +3112 -0
  55. package/src/sany-levels.ts +1208 -0
  56. package/src/sany-lexer.ts +545 -0
  57. package/src/sany-linter.ts +122 -0
  58. package/src/sany-modules.ts +1398 -0
  59. package/src/sany-nodes.ts +463 -0
  60. package/src/sany-parse-error.ts +2161 -0
  61. package/src/sany-report.ts +354 -0
  62. package/src/sany-selectors.ts +738 -0
  63. package/src/sany-source.ts +248 -0
  64. package/src/sany-xml.ts +1017 -0
  65. package/src/spec-description.ts +42 -11
  66. package/src/standard-modules.ts +200 -148
  67. package/src/standard-ranges.ts +116 -0
  68. package/src/state-graph.ts +180 -0
  69. package/src/subexpressions.ts +231 -171
  70. package/src/substitution-levels.ts +38 -17
  71. package/src/successors.ts +219 -107
  72. package/src/symmetry.ts +180 -52
  73. package/src/tableau.ts +54 -25
  74. package/src/tlc-ext.ts +42 -29
  75. package/src/tlc-messages.ts +329 -0
  76. package/src/tlc-module.ts +52 -43
  77. package/src/tlc-order.ts +73 -9
  78. package/src/tlc-random.ts +37 -9
  79. package/src/tlc-replay.ts +655 -0
  80. package/src/tlc-summary.ts +20 -5
  81. package/src/tlc-version.ts +18 -0
  82. package/src/transfer.ts +15 -3
  83. package/src/value-sources.ts +29 -0
  84. package/src/values.ts +708 -180
@@ -1,23 +1,33 @@
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";
13
14
  import type { FileSystem } from "./json";
14
- import { TlaConfigError, TlaEvaluationError, TlaSyntaxError } from "./errors";
15
+ import {
16
+ createSanyError,
17
+ createMissingModuleError,
18
+ formatRange,
19
+ formatSanyWarnings,
20
+ TlaConfigError,
21
+ TlaEvaluationError,
22
+ TlaSyntaxError,
23
+ type SanyError,
24
+ } from "./errors";
15
25
  import { EXIT_STATUS, setExitCode } from "./exit-codes";
16
26
  import {
17
27
  createBigNumberError,
18
28
  createRealNumberError,
19
- getChildren,
20
- isConstantLevel,
29
+ evaluate,
30
+ getDefinition,
21
31
  isTlcInteger,
22
32
  type Builtin,
23
33
  type Environment,
@@ -28,24 +38,39 @@ import {
28
38
  renameLocals,
29
39
  withLetInstances,
30
40
  } from "./instances";
31
- import { overrideDefinitions } from "./java-overrides";
41
+ import { overrideDefinitions, type JavaOverride } from "./java-overrides";
32
42
  import { extractModule, parseModule } from "./parser";
33
43
  import {
34
- checkRedefinitions,
35
44
  getArity,
45
+ getParamArities,
36
46
  isBefore,
47
+ isTheoremDefinition,
37
48
  KEY_SEPARATOR,
38
49
  LOCAL_RESOLUTION,
50
+ MODULE_START,
39
51
  resolveModule,
40
52
  resolveSubstitutions,
53
+ type ModuleReport,
41
54
  type ModuleSymbol,
55
+ type ModuleUnit,
56
+ type SymbolKind,
42
57
  type Symbols,
43
58
  } from "./resolve";
44
59
  import { createRuntime } from "./runtime";
45
- import { CORE_OPERATORS, getStandardModule, STANDARD_DEPENDENCIES } from "./standard-modules";
60
+ import { getSanyParseError } from "./sany-parse-error";
61
+ import {
62
+ CORE_OPERATORS,
63
+ getStandardModule,
64
+ getTraceSpecArithmetic,
65
+ STANDARD_DEPENDENCIES,
66
+ } from "./standard-modules";
67
+ import { STANDARD_LEVELS } from "./standard-levels";
68
+ import { getStandardRange } from "./standard-ranges";
46
69
  import { resolveInstanceSubexpressions, resolveModuleSubexpressions } from "./subexpressions";
47
- import { checkModuleLevels } from "./levels";
48
- import { checkInstances, type InstanceCheck } from "./substitution-levels";
70
+ import { checkModuleLevels, createLevelAnalyzer } from "./levels";
71
+ import { createInstanceChecker, type InstanceCheck } from "./substitution-levels";
72
+ import { isEvalException } from "./tlc-messages";
73
+ import { createTlcDefinitionOrder, getTlcDeclarationOrder } from "./tlc-order";
49
74
  import {
50
75
  checkInteger,
51
76
  createModelValue,
@@ -53,7 +78,9 @@ import {
53
78
  formatValue,
54
79
  valuesEqual,
55
80
  type Value,
81
+ markNormalized,
56
82
  } from "./values";
83
+ import type { TlcVersion } from "./tlc-version";
57
84
 
58
85
  interface EnvironmentOptions {
59
86
  source: string;
@@ -62,6 +89,15 @@ interface EnvironmentOptions {
62
89
  print: (text: string) => void;
63
90
  files: FileSystem;
64
91
  seed?: bigint;
92
+ // Links the modules without a model, as SANY does, so a declared constant needs no value.
93
+ isUnconfigured?: boolean;
94
+ isTool?: boolean;
95
+ // TLC loads Integers for the binary trace of its trace exploration spec, and Integers' Java
96
+ // methods then compute the arithmetic of Naturals.
97
+ isTraceRecorded?: boolean;
98
+ isSanyReported?: boolean;
99
+ isWarningEnabled?: boolean;
100
+ version?: TlcVersion;
65
101
  }
66
102
 
67
103
  interface Specification {
@@ -69,6 +105,12 @@ interface Specification {
69
105
  assumptions: Assumption[];
70
106
  variableLocations: SourceLocation[];
71
107
  instanceActions: Map<string, InstanceAction>;
108
+ // The definitions TLC computes when it starts, in the order it computes them.
109
+ startupDefinitions: Definition[];
110
+ rootConstants: Declaration[];
111
+ rootSymbols: Symbols;
112
+ // The methods of the modules' classes, in the order TLC loads the classes.
113
+ javaOverrides: JavaOverride[];
72
114
  }
73
115
 
74
116
  export interface InstanceAction {
@@ -104,25 +146,73 @@ interface LinkedModule {
104
146
  exported: Symbols;
105
147
  modules: Map<string, LinkedModule>;
106
148
  extended: LinkedModule[];
149
+ facts: Set<string>;
107
150
  }
108
151
 
152
+ // errors and warnings collect what SANY reports for the module, and levelChecks the level checks of
153
+ // the modules in its file, which SANY runs only when it reports no error.
109
154
  interface ModuleScope {
110
155
  id: string;
111
156
  symbols: Symbols;
112
157
  modules: Map<string, LinkedModule>;
113
158
  nested: Module[];
159
+ errors: SanyError[];
160
+ warnings: SanyError[];
161
+ levelChecks: (() => void)[];
114
162
  }
115
163
 
116
- const getDeclarations = (linked: LinkedModule) => [
164
+ const getDeclarations = (linked: LinkedModule): Declaration[] => [
117
165
  ...linked.constants,
118
- ...linked.variables.map((variable) => ({ name: variable, arity: 0 })),
166
+ ...linked.variables.map((variable, index) => ({
167
+ name: variable,
168
+ arity: 0,
169
+ location: linked.variableLocations[index],
170
+ })),
119
171
  ];
120
172
 
173
+ // Parses the module SANY reads from the file name.tla. A module SANY's parser rejects fails as it
174
+ // does in TLC: SANY's message, then a fatal error that names the module.
175
+ const parseModuleFile = (source: string, name: string) => {
176
+ try {
177
+ return parseModule(source);
178
+ } catch (error) {
179
+ if (!(error instanceof TlaSyntaxError)) throw error;
180
+ const parseError = getSanyParseError(source);
181
+ if (parseError === undefined) throw error;
182
+ throw createSanyError(
183
+ [
184
+ {
185
+ location: `In module ${name}`,
186
+ message: `Could not parse module ${name} from file ${name}.tla`,
187
+ },
188
+ ],
189
+ true,
190
+ parseError,
191
+ );
192
+ }
193
+ };
194
+
121
195
  const createModuleRedefinedError = (module: Module) =>
122
196
  new TlaSyntaxError(
123
197
  `Multiply-defined module '${module.name}' at line ${module.location.line}, column ${module.location.column}`,
124
198
  );
125
199
 
200
+ const getModuleRedefinition = (module: Module, existing: Module): SanyError | undefined =>
201
+ module.location.range &&
202
+ existing.location.range && {
203
+ location: formatRange(module.location.range),
204
+ message: `Multiply-defined module '${module.name}': this definition or declaration conflicts \nwith the one at ${formatRange(existing.location.range)}.`,
205
+ };
206
+
207
+ // Context.kindOfNode names a definition or a parameter a definition, and any other symbol a
208
+ // declaration.
209
+ const getNodeWord = (kind: SymbolKind) =>
210
+ ["Builtin", "Definition", "Instance", "Parameter"].includes(kind) ? "definition" : "declaration";
211
+
212
+ // The Java class of the node SANY binds a symbol to.
213
+ const getNodeClass = (kind: SymbolKind) =>
214
+ kind === "Theorem" ? "ThmOrAssumpDefNode" : getNodeWord(kind);
215
+
126
216
  const createLocalFunction = (definition: Definition, key: string): Definition => ({
127
217
  kind: "Operator",
128
218
  name: key,
@@ -212,13 +302,21 @@ export const createEnvironment = (
212
302
  const root = parseModule(options.source);
213
303
  const definitions = new Map<string, Definition>();
214
304
  const parameterized = new Map<string, boolean>();
305
+ // The definition each instance copy came from, and the instance parameters the copy adds.
306
+ const copySources = new Map<string, { source: string; prefix: number }>();
307
+ const substitutedDefinitions = new Set<Definition>();
215
308
  const builtins = new Map<string, Builtin>(
216
309
  CORE_OPERATORS.map((operator) => [operator.name, operator]),
217
310
  );
218
311
  const standardExports = new Map<string, Symbols>();
219
312
  const runtime = createRuntime(config.checkDeadlock, options.seed);
313
+ runtime.isWarningEnabled = options.isWarningEnabled ?? true;
314
+ runtime.isTool = options.isTool ?? false;
315
+ runtime.version = options.version ?? "master";
220
316
  const linkedModules = new Map<string, LinkedModule>();
221
317
  const nestedModules = new Map<string, LinkedModule>();
318
+ // Each module by name, from the time its level checks run.
319
+ const checkedModules = new Map<string, LinkedModule>();
222
320
  const linkedList: LinkedModule[] = [];
223
321
  const dependencies = new Map<string, Set<string>>();
224
322
  const loading: Set<string>[] = [];
@@ -233,13 +331,35 @@ export const createEnvironment = (
233
331
  const copyCount = { value: 0 };
234
332
  const createName = (name: string) => `${name}#${copyCount.value++}`;
235
333
  const instanceChecks: InstanceCheck[] = [];
334
+ // The warnings SANY reports for the spec.
335
+ const warnings: SanyError[] = [];
336
+ const checkInstance = createInstanceChecker((name) => {
337
+ const linked = checkedModules.get(name) ?? getLinkedModule(name, name);
338
+ return {
339
+ constants: linked.constants,
340
+ variables: linked.variables,
341
+ definitions: [
342
+ ...new Set(
343
+ [...linked.visible.values()].flatMap((symbol) => definitions.get(symbol.key) ?? []),
344
+ ),
345
+ ],
346
+ assumptions: linked.module.assumptions.map((assumption) => assumption.expression),
347
+ theorems: linked.module.theorems,
348
+ getDefinition: (symbol) => definitions.get(linked.visible.get(symbol)?.key ?? symbol),
349
+ };
350
+ });
236
351
  const instanceActions = new Map<string, InstanceAction>();
352
+ const instanceNames = new Map<string, string>();
353
+ const qualifiedNames = new Map<string, string>();
237
354
 
238
355
  const addStandardModule = (name: string): Symbols | undefined => {
239
356
  const cached = standardExports.get(name);
240
357
  if (cached) return cached;
241
- const standardModule = getStandardModule(name, options.print, runtime, options.files);
358
+ const standardModule = getStandardModule(name, options.print, runtime, options.files, builtins);
242
359
  if (!standardModule) return undefined;
360
+ // TLC loads the modules a standard module instantiates too, and the Java methods of each
361
+ // replace the operators of every module, as those of Integers replace those of Naturals.
362
+ STANDARD_DEPENDENCIES.get(name)?.forEach(addStandardModule);
243
363
  const exported: Symbols = new Map();
244
364
  standardModule.extends.forEach((extended) =>
245
365
  addStandardModule(extended)?.forEach((symbol, symbolName) =>
@@ -248,7 +368,13 @@ export const createEnvironment = (
248
368
  );
249
369
  standardModule.operators.forEach((operator) => {
250
370
  builtins.set(operator.name, operator);
251
- exported.set(operator.name, { key: operator.name, arity: operator.arity });
371
+ exported.set(operator.name, {
372
+ key: operator.name,
373
+ arity: operator.arity,
374
+ params: STANDARD_LEVELS.get(operator.name)?.formals.map((formal) => formal.arity),
375
+ kind: "Definition",
376
+ range: getStandardRange(name, operator.name) ?? exported.get(operator.name)?.range,
377
+ });
252
378
  });
253
379
  standardExports.set(name, exported);
254
380
  return exported;
@@ -256,7 +382,11 @@ export const createEnvironment = (
256
382
 
257
383
  const getStandardSymbols = (name: string) => {
258
384
  const symbols = addStandardModule(name);
259
- if (symbols) useModule(name, STANDARD_DEPENDENCIES.get(name) ?? []);
385
+ const dependencies = STANDARD_DEPENDENCIES.get(name) ?? [];
386
+ if (symbols) useModule(name, dependencies);
387
+ // TLC loads the Java class of each module a standard module uses, so one that uses Integers
388
+ // overrides the arithmetic of Naturals.
389
+ if (symbols && dependencies.includes("Integers")) addStandardModule("Integers");
260
390
  return symbols;
261
391
  };
262
392
 
@@ -284,14 +414,17 @@ export const createEnvironment = (
284
414
  options.loadModule?.(name) ??
285
415
  BUNDLED_MODULES.get(name) ??
286
416
  extractModule(options.source, name);
287
- if (source === undefined)
288
- throw new TlaSyntaxError(
289
- `Cannot find source file for module ${name} imported in module ${importer}.`,
290
- );
291
- const module = parseModule(source);
417
+ if (source === undefined) throw createMissingModuleError(name, importer);
418
+ const module = parseModuleFile(source, name);
292
419
  if (module.name !== name) {
293
- throw new TlaSyntaxError(
294
- `File name '${name}' does not match the name '${module.name}' of the top level module it contains.`,
420
+ throw createSanyError(
421
+ [
422
+ {
423
+ location: "Unknown location",
424
+ message: `File name '${name}' does not match the name '${module.name}' of the top level module it contains.`,
425
+ },
426
+ ],
427
+ true,
295
428
  );
296
429
  }
297
430
  return rejectModuleLiterals(module);
@@ -307,6 +440,8 @@ export const createEnvironment = (
307
440
  }
308
441
  const closure = new Set<string>();
309
442
  const nested: Module[] = [];
443
+ const errors: SanyError[] = [];
444
+ const levelChecks: (() => void)[] = [];
310
445
  linking.push(parsed.name);
311
446
  loading.push(closure);
312
447
  const linked = linkModule(parsed, {
@@ -314,11 +449,19 @@ export const createEnvironment = (
314
449
  symbols: new Map(),
315
450
  modules: new Map(),
316
451
  nested,
452
+ errors,
453
+ warnings,
454
+ levelChecks,
317
455
  });
318
456
  loading.pop();
319
457
  linking.pop();
458
+ if (errors.length > 0) throw createSanyError(errors, false, undefined, warnings);
320
459
  const duplicate = nested.find((module) => closure.has(module.name));
460
+ const loaded = duplicate && linkedModules.get(duplicate.name);
461
+ const redefinition = loaded && getModuleRedefinition(duplicate, loaded.module);
462
+ if (redefinition) throw createSanyError([redefinition], false, undefined, warnings);
321
463
  if (duplicate) throw createModuleRedefinedError(duplicate);
464
+ levelChecks.forEach((check) => check());
322
465
  return { linked, closure };
323
466
  };
324
467
 
@@ -338,23 +481,16 @@ export const createEnvironment = (
338
481
  const instantiate = (
339
482
  instance: Instance,
340
483
  module: Module,
341
- unit: {
342
- imported: Symbols;
343
- importedAt: Map<string, SourceLocation>;
344
- definitions: Map<string, Definition>;
345
- getKey: (definition: Definition) => string;
346
- },
484
+ unit: ModuleUnit,
347
485
  isParameterFree: boolean,
348
486
  nested: LinkedModule | undefined,
349
487
  ): Symbols => {
350
488
  const standardSymbols = nested ? undefined : getStandardSymbols(instance.module);
351
- if (standardSymbols) {
352
- if (instance.name === undefined) return standardSymbols;
353
- return new Map(
354
- [...standardSymbols].map(([name, symbol]) => [`${instance.name}!${name}`, symbol]),
355
- );
356
- }
489
+ if (standardSymbols) return getStandardInstanceSymbols(instance, standardSymbols);
357
490
  const linked = nested ?? getLinkedModule(instance.module, module.name);
491
+ linked.facts.forEach((name) =>
492
+ unit.facts.add(instance.name === undefined ? name : `${instance.name}!${name}`),
493
+ );
358
494
  const declarations = getDeclarations(linked);
359
495
  const suffix = `#${copyCount.value++}`;
360
496
  const renamed = new Map(instance.params.map((param) => [param.name, `${param.name}${suffix}`]));
@@ -379,35 +515,83 @@ export const createEnvironment = (
379
515
  variables: new Set(linked.variables),
380
516
  getDefinition: (key) => definitions.get(key),
381
517
  isParameterized: (key) => parameterized.get(key) === true,
382
- addDefinition: (name, create) => {
518
+ addDefinition: (source, name, create) => {
383
519
  const key = createName(`${name}@${module.name}`);
384
- definitions.set(key, create(key));
520
+ const definition = create(key);
521
+ definitions.set(key, definition);
522
+ if (declarations.length > 0) substitutedDefinitions.add(definition);
523
+ if (instance.name !== undefined) {
524
+ instanceNames.set(key, `${instance.name}!${instanceNames.get(source) ?? name}`);
525
+ }
385
526
  parameterized.set(key, !isParameterFree);
527
+ copySources.set(key, { source, prefix: instance.params.length });
386
528
  return key;
387
529
  },
388
530
  createName,
389
531
  });
390
- const declared = new Set(declarations.map((declaration) => declaration.name));
391
- const symbols: Symbols = new Map();
392
- linked.exported.forEach((symbol, name) => {
393
- if (declared.has(name)) return;
394
- if (instance.name === undefined) {
395
- const key = instantiation.getKey(symbol.key);
396
- if (declarations.length > 0)
397
- instanceActions.set(key, { name, location: instance.location });
398
- symbols.set(name, { key, arity: symbol.arity });
399
- return;
400
- }
401
- const key = instantiation.getQualifiedKey(symbol.key);
402
- if (declarations.length > 0) {
403
- instanceActions.set(key, { name: `${instance.name}!${name}`, location: instance.location });
404
- }
405
- symbols.set(`${instance.name}!${name}`, {
406
- key,
407
- arity: symbol.arity + instance.params.length,
408
- });
532
+ return getInstanceSymbols(instance, linked.exported, declarations, (key, name) => {
533
+ const copy =
534
+ instance.name === undefined
535
+ ? instantiation.getKey(key)
536
+ : instantiation.getQualifiedKey(key);
537
+ if (declarations.length > 0) instanceActions.set(copy, { name, location: instance.location });
538
+ if (instance.name !== undefined) qualifiedNames.set(copy, name);
539
+ return copy;
409
540
  });
410
- return symbols;
541
+ };
542
+
543
+ const getStandardInstanceSymbols = (instance: Instance, standardSymbols: Symbols): Symbols =>
544
+ instance.name === undefined
545
+ ? standardSymbols
546
+ : new Map(
547
+ [...standardSymbols].map(([name, symbol]) => [
548
+ `${instance.name}!${name}`,
549
+ { key: symbol.key, arity: symbol.arity, params: symbol.params, kind: symbol.kind },
550
+ ]),
551
+ );
552
+
553
+ // The names an INSTANCE adds for the definitions of the module it instantiates, each with the key
554
+ // that getKey gives it. SANY binds a copy of a definition that depends on the parameters at the
555
+ // INSTANCE.
556
+ const getInstanceSymbols = (
557
+ instance: Instance,
558
+ exported: Symbols,
559
+ declarations: Declaration[],
560
+ getKey: (key: string, name: string) => string,
561
+ ): Symbols => {
562
+ const declared = new Set(declarations.map((declaration) => declaration.name));
563
+ return new Map(
564
+ [...exported]
565
+ .filter(([name]) => !declared.has(name))
566
+ .map(([name, symbol]): [string, ModuleSymbol] => {
567
+ if (instance.name === undefined) {
568
+ return [
569
+ name,
570
+ {
571
+ key: getKey(symbol.key, name),
572
+ arity: symbol.arity,
573
+ params: symbol.params,
574
+ kind: symbol.kind,
575
+ range:
576
+ parameterized.get(symbol.key) === true ? instance.location.range : symbol.range,
577
+ },
578
+ ];
579
+ }
580
+ const qualified = `${instance.name}!${name}`;
581
+ return [
582
+ qualified,
583
+ {
584
+ key: getKey(symbol.key, qualified),
585
+ arity: symbol.arity + instance.params.length,
586
+ params: symbol.params && [
587
+ ...instance.params.map((param) => param.arity),
588
+ ...symbol.params,
589
+ ],
590
+ kind: symbol.kind,
591
+ },
592
+ ];
593
+ }),
594
+ );
411
595
  };
412
596
 
413
597
  const getLocalArguments = (params: OperatorParam[], location: SourceLocation) =>
@@ -544,7 +728,7 @@ export const createEnvironment = (
544
728
  variables: new Set(linked.variables),
545
729
  getDefinition: (key) => definitions.get(key),
546
730
  isParameterized: (key) => parameterized.get(key) === true,
547
- addDefinition: (name, create) => {
731
+ addDefinition: (_source, name, create) => {
548
732
  const key = `${name}${KEY_SEPARATOR}${instance.module}${suffix}.${copies.length}`;
549
733
  const definition = create(key);
550
734
  copies.push(
@@ -580,31 +764,70 @@ export const createEnvironment = (
580
764
  return definition ? [{ ...definition, name }] : [];
581
765
  });
582
766
 
767
+ const javaOverrides = new Map<string, JavaOverride[]>();
583
768
  const linkModule = (unlinked: Module, scope: ModuleScope): LinkedModule => {
584
- const parsed = overrideDefinitions(unlinked, options.loadClass?.(unlinked.name));
769
+ const overridden = overrideDefinitions(
770
+ unlinked,
771
+ options.loadClass?.(unlinked.name),
772
+ unlinked === root,
773
+ );
774
+ javaOverrides.set(unlinked.name, overridden.overrides);
775
+ const parsed = overridden.module;
776
+ const firstCheck = instanceChecks.length;
585
777
  const visible: Symbols = new Map([
586
778
  ...CORE_OPERATORS.map((operator): [string, ModuleSymbol] => [
587
779
  operator.name,
588
- { key: operator.name, arity: operator.arity },
780
+ { key: operator.name, arity: operator.arity, kind: "Builtin" },
589
781
  ]),
590
782
  ...scope.symbols,
591
783
  ]);
784
+ // Where an INSTANCE first made each name it adds visible.
785
+ const importedAt = new Map<string, SourceLocation>();
786
+ const extendsReport: ModuleReport = { location: MODULE_START, errors: [], warnings: [] };
787
+ const reports = [extendsReport];
788
+ // Context.mergeExtendContext keeps the first of the symbols the extended modules share by name,
789
+ // and warns of two definitions or two declarations but rejects a definition and a declaration.
790
+ const mergeExtended = (symbols: Symbols) =>
791
+ symbols.forEach((symbol, name) => {
792
+ const current = exported.get(name);
793
+ if (!current) {
794
+ visible.set(name, symbol);
795
+ exported.set(name, symbol);
796
+ return;
797
+ }
798
+ if (
799
+ !current.range ||
800
+ !symbol.range ||
801
+ formatRange(current.range) === formatRange(symbol.range)
802
+ ) {
803
+ return;
804
+ }
805
+ const location = formatRange(symbol.range);
806
+ const existing = formatRange(current.range);
807
+ if (getNodeClass(current.kind) === getNodeClass(symbol.kind)) {
808
+ extendsReport.warnings.push({
809
+ location,
810
+ message: `Warning: the ${getNodeWord(current.kind)} of '${name}' conflicts with \nits ${getNodeWord(current.kind)} at ${existing}.`,
811
+ });
812
+ return;
813
+ }
814
+ extendsReport.errors.push({
815
+ location,
816
+ message: `The ${getNodeWord(symbol.kind)} of '${name}' conflicts with \nits ${getNodeWord(current.kind)} at ${existing}.`,
817
+ });
818
+ });
592
819
  const exported: Symbols = new Map();
820
+ const facts = new Set<string>();
593
821
  const modules = new Map<string, LinkedModule>();
594
822
  const extended: LinkedModule[] = [];
595
823
  const constants = [...parsed.constants];
596
824
  const variables = parsed.variables.map((variable) => variable.name);
597
825
  const variableLocations = parsed.variables.map((variable) => variable.location);
598
- const addSymbols = (symbols: Symbols, isExported: boolean) =>
599
- symbols.forEach((symbol, name) => {
600
- visible.set(name, symbol);
601
- if (isExported) exported.set(name, symbol);
602
- });
603
826
  parsed.extends.forEach((name) => {
604
827
  const nested = scope.modules.get(name);
605
828
  const standardSymbols = nested ? undefined : getStandardSymbols(name);
606
829
  if (standardSymbols) {
607
- addSymbols(standardSymbols, true);
830
+ mergeExtended(standardSymbols);
608
831
  return;
609
832
  }
610
833
  const linked = nested ?? getLinkedModule(name, parsed.name);
@@ -618,61 +841,114 @@ export const createEnvironment = (
618
841
  variables.push(variable);
619
842
  variableLocations.push(linked.variableLocations[index]);
620
843
  });
621
- addSymbols(linked.exported, true);
844
+ mergeExtended(linked.exported);
845
+ linked.facts.forEach((name) => facts.add(name));
622
846
  linked.modules.forEach((module, moduleName) => modules.set(moduleName, module));
623
847
  extended.push(linked);
624
848
  });
625
- parsed.constants.forEach((constant) =>
626
- exported.set(constant.name, {
627
- key: constant.name,
628
- arity: constant.arity,
629
- declaration: "Constant",
630
- }),
631
- );
632
- parsed.variables.forEach((variable) =>
633
- exported.set(variable.name, { key: variable.name, arity: 0, declaration: "Variable" }),
849
+ const bound = new Map(visible);
850
+ const declarations = [
851
+ ...parsed.constants.map((constant) => ({ ...constant, kind: "Constant" as const })),
852
+ ...parsed.variables.map((variable) => ({ ...variable, kind: "Variable" as const })),
853
+ ];
854
+ const getDeclarationSymbol = (declaration: (typeof declarations)[number]): ModuleSymbol => ({
855
+ key: declaration.name,
856
+ arity: declaration.arity,
857
+ kind: declaration.kind,
858
+ range: declaration.location.range,
859
+ });
860
+ declarations.forEach((declaration) =>
861
+ exported.set(declaration.name, getDeclarationSymbol(declaration)),
634
862
  );
863
+ const getDefinitionSymbol = (definition: Definition): ModuleSymbol => ({
864
+ key: getKey(definition),
865
+ arity: getArity(definition),
866
+ params: getParamArities(definition),
867
+ kind: isTheoremDefinition(parsed, definition) ? "Theorem" : "Definition",
868
+ range: definition.location.range,
869
+ });
635
870
  const isParameterFree = constants.length === 0 && variables.length === 0;
636
871
  const getKey = (definition: Definition) =>
637
872
  parsed === root ? definition.name : `${definition.name}${KEY_SEPARATOR}${scope.id}`;
638
- const importedAt = new Map<string, SourceLocation>();
639
- const getUnit = (module: Module) => ({
873
+ const instanced = new Map<Instance, Symbols>();
874
+ const getVisibleModules = () => new Map([...scope.modules, ...modules]);
875
+ const isInstancedAfterDefinition = (nested: Module) => {
876
+ const first = parsed.instances.find((instance) => instance.module === nested.name);
877
+ return first !== undefined && isBefore(nested.location, first.location);
878
+ };
879
+ const getLetModule = (instance: Instance) => {
880
+ const own = parsed.modules.find((nested) => nested.name === instance.module);
881
+ if (!own) return getVisibleModules().get(instance.module);
882
+ return isInstancedAfterDefinition(own) ? modules.get(own.name) : undefined;
883
+ };
884
+ const getUnit = (module: Module): ModuleUnit => ({
640
885
  imported: visible,
641
- importedAt,
642
- definitions: new Map(module.definitions.map((definition) => [definition.name, definition])),
886
+ getInstance: (instance) => {
887
+ const nested = getLetModule(instance);
888
+ const standardSymbols = nested ? undefined : getStandardSymbols(instance.module);
889
+ if (standardSymbols) {
890
+ return {
891
+ declarations: [],
892
+ symbols: getStandardInstanceSymbols(instance, standardSymbols),
893
+ instancer: parsed.name,
894
+ };
895
+ }
896
+ const linked = nested ?? getLinkedModule(instance.module, parsed.name);
897
+ const declarations = getDeclarations(linked);
898
+ return {
899
+ declarations,
900
+ symbols: getInstanceSymbols(instance, linked.exported, declarations, (key) => key),
901
+ instancer: parsed.name,
902
+ };
903
+ },
904
+ bound,
905
+ // SANY keeps the first of two definitions of a name.
906
+ definitions: new Map(
907
+ module.definitions.toReversed().map((definition) => [definition.name, definition]),
908
+ ),
643
909
  getKey,
910
+ instanced,
911
+ facts,
912
+ reports,
913
+ warnings: scope.warnings,
644
914
  });
645
- const getVisibleModules = () => new Map([...scope.modules, ...modules]);
646
915
  const getSymbolsBefore = (location: SourceLocation): Symbols =>
647
916
  new Map([
648
917
  ...visible,
649
- ...[
650
- ...parsed.constants.map((constant) => ({ ...constant, kind: "Constant" as const })),
651
- ...parsed.variables.map((variable) => ({ ...variable, kind: "Variable" as const })),
652
- ]
918
+ ...declarations
653
919
  .filter((declaration) => isBefore(declaration.location, location))
654
920
  .map((declaration): [string, ModuleSymbol] => [
655
921
  declaration.name,
656
- { key: declaration.name, arity: declaration.arity, declaration: declaration.kind },
922
+ getDeclarationSymbol(declaration),
657
923
  ]),
658
924
  ...parsed.definitions
659
925
  .filter((definition) => isBefore(definition.location, location))
660
926
  .map((definition): [string, ModuleSymbol] => [
661
927
  definition.name,
662
- { key: getKey(definition), arity: getArity(definition) },
928
+ getDefinitionSymbol(definition),
663
929
  ]),
664
930
  ]);
931
+ // Generator.generateModule reports the errors of a nested module and goes on, and then
932
+ // SymbolTable.addModule reports a module already defined.
665
933
  const linkNested = (nested: Module) => {
666
934
  const visibleModules = getVisibleModules();
667
- if (visibleModules.has(nested.name)) throw createModuleRedefinedError(nested);
935
+ const existing = visibleModules.get(nested.name);
936
+ const redefinition = existing && getModuleRedefinition(nested, existing.module);
937
+ if (existing && !redefinition) throw createModuleRedefinedError(nested);
668
938
  scope.nested.push(nested);
939
+ const report: ModuleReport = { location: nested.location, errors: [], warnings: [] };
940
+ reports.push(report);
669
941
  const linked = linkModule(nested, {
670
942
  id: `${scope.id}/${nested.name}`,
671
943
  symbols: getSymbolsBefore(nested.location),
672
944
  modules: visibleModules,
673
945
  nested: scope.nested,
946
+ errors: report.errors,
947
+ warnings: report.warnings,
948
+ levelChecks: scope.levelChecks,
674
949
  });
675
- modules.set(nested.name, linked);
950
+ if (redefinition) report.errors.push(redefinition);
951
+ if (!existing) modules.set(nested.name, linked);
676
952
  if (!nestedModules.has(nested.name)) nestedModules.set(nested.name, linked);
677
953
  };
678
954
  [
@@ -686,10 +962,13 @@ export const createEnvironment = (
686
962
  isParameterFree,
687
963
  getVisibleModules().get(instance.module),
688
964
  );
689
- symbols.forEach((_, name) => {
690
- if (!visible.has(name)) importedAt.set(name, instance.location);
965
+ instanced.set(instance, symbols);
966
+ symbols.forEach((symbol, name) => {
967
+ if (visible.has(name)) return;
968
+ importedAt.set(name, instance.location);
969
+ visible.set(name, symbol);
970
+ if (!instance.isLocal) exported.set(name, symbol);
691
971
  });
692
- addSymbols(symbols, !instance.isLocal);
693
972
  },
694
973
  })),
695
974
  ...parsed.modules.map((nested) => ({
@@ -699,36 +978,30 @@ export const createEnvironment = (
699
978
  ]
700
979
  .sort((left, right) => (isBefore(left.location, right.location) ? -1 : 1))
701
980
  .forEach((unit) => unit.link());
702
- checkRedefinitions(parsed, getUnit(parsed));
703
- const isInstancedAfterDefinition = (nested: Module) => {
704
- const first = parsed.instances.find((instance) => instance.module === nested.name);
705
- return first !== undefined && isBefore(nested.location, first.location);
706
- };
707
- const getLetModule = (instance: Instance) => {
708
- const own = parsed.modules.find((nested) => nested.name === instance.module);
709
- if (!own) return getVisibleModules().get(instance.module);
710
- return isInstancedAfterDefinition(own) ? modules.get(own.name) : undefined;
711
- };
712
981
  const module = resolveModuleSubexpressions(
713
982
  withLetInstances(parsed, (instance, lets) =>
714
983
  instantiateLocally(instance, lets, parsed.name, getLetModule(instance)),
715
984
  ),
716
985
  getAvailableDefinitions(visible),
717
986
  );
718
- resolveModule(module, getUnit(module));
987
+ scope.errors.push(...resolveModule(module, getUnit(module)));
719
988
  module.definitions.forEach((definition) => {
720
989
  const key = getKey(definition);
721
990
  definitions.set(key, definition);
722
991
  parameterized.set(key, !isParameterFree);
723
- const symbol = { key, arity: getArity(definition) };
992
+ const symbol = getDefinitionSymbol(definition);
993
+ const importedLocation = importedAt.get(definition.name);
994
+ // SANY binds the name of a fact to a fact the module imports before it.
995
+ if (
996
+ symbol.kind === "Theorem" &&
997
+ visible.get(definition.name)?.kind === "Theorem" &&
998
+ (importedLocation === undefined || isBefore(importedLocation, definition.location))
999
+ ) {
1000
+ return;
1001
+ }
724
1002
  visible.set(definition.name, symbol);
725
1003
  if (!definition.isLocal) exported.set(definition.name, symbol);
726
1004
  });
727
- checkModuleLevels(module, {
728
- constants: new Set(constants.map((constant) => constant.name)),
729
- variables: new Set(variables),
730
- getDefinition: (symbol) => definitions.get(visible.get(symbol)?.key ?? symbol),
731
- });
732
1005
  const linked = {
733
1006
  module,
734
1007
  constants,
@@ -738,12 +1011,36 @@ export const createEnvironment = (
738
1011
  exported,
739
1012
  modules,
740
1013
  extended,
1014
+ facts: new Set([
1015
+ ...facts,
1016
+ ...[...module.theorems, ...module.assumptions].flatMap((fact) => fact.name ?? []),
1017
+ ]),
741
1018
  };
1019
+ if (!checkedModules.has(parsed.name)) checkedModules.set(parsed.name, linked);
1020
+ // SANY checks the instances of a module with its definitions and theorems, so it reports their
1021
+ // errors together.
1022
+ const checks = instanceChecks
1023
+ .splice(firstCheck)
1024
+ .map((check) => ({ location: check.location, check: () => checkInstance(check) }));
1025
+ scope.levelChecks.push(() =>
1026
+ checkModuleLevels(
1027
+ module,
1028
+ {
1029
+ constants: new Set(constants.map((constant) => constant.name)),
1030
+ variables: new Set(variables),
1031
+ getDefinition: (symbol) => definitions.get(visible.get(symbol)?.key ?? symbol),
1032
+ getQualifiedName: (symbol) => qualifiedNames.get(visible.get(symbol)?.key ?? symbol),
1033
+ },
1034
+ checks,
1035
+ warnings,
1036
+ ),
1037
+ );
742
1038
  linkedList.push(linked);
743
1039
  return linked;
744
1040
  };
745
1041
 
746
1042
  const linkedRoot = linkTopLevel(root).linked;
1043
+ if (warnings.length > 0 && !options.isSanyReported) options.print(formatSanyWarnings(warnings));
747
1044
  const getRootKey = (name: string) => linkedRoot.visible.get(name)?.key ?? name;
748
1045
  linkedRoot.visible.forEach((symbol, name) => {
749
1046
  const definition = definitions.get(symbol.key);
@@ -785,6 +1082,7 @@ export const createEnvironment = (
785
1082
  .filter((assignment) => assignment.args === undefined)
786
1083
  .forEach((assignment) => {
787
1084
  const value = toValue(assignment.value);
1085
+ markNormalized(value);
788
1086
  getScopedKeys(assignment).forEach((key) => {
789
1087
  const arity = getKeyArity(key);
790
1088
  if (arity === 0) constants.set(key, value);
@@ -872,11 +1170,58 @@ export const createEnvironment = (
872
1170
  );
873
1171
  }
874
1172
  });
875
- declaredConstants.forEach((name) => {
876
- if (!constants.has(name) && !substitutions.has(name) && !operatorKeys.has(name)) {
877
- throw new TlaConfigError(`The constant ${name} is not assigned a value by the configuration`);
878
- }
1173
+ // TLC sets a module-scoped entry on the body of the module's definition, which every instance of
1174
+ // the module shares.
1175
+ const scopedKeys = new Set(
1176
+ [...config.constants, ...config.substitutions]
1177
+ .filter((item) => item.module !== undefined)
1178
+ .flatMap(getScopedKeys),
1179
+ );
1180
+ const getOverride = (
1181
+ key: string,
1182
+ prefix: number,
1183
+ ): { key: string; prefix: number } | undefined => {
1184
+ if (scopedKeys.has(key)) return { key, prefix };
1185
+ const copy = copySources.get(key);
1186
+ return copy && getOverride(copy.source, prefix + copy.prefix);
1187
+ };
1188
+ copySources.forEach((copy, key) => {
1189
+ const override = getOverride(copy.source, copy.prefix);
1190
+ const definition = definitions.get(key);
1191
+ if (!override || !definition) return;
1192
+ const params = definition.kind === "Operator" ? definition.params : [];
1193
+ const alias = createLocalAlias(
1194
+ key,
1195
+ override.key,
1196
+ params,
1197
+ params.slice(override.prefix),
1198
+ definition.location,
1199
+ );
1200
+ definitions.set(key, alias);
1201
+ linkedRoot.visible.forEach((symbol, name) => {
1202
+ if (symbol.key === key && name !== key) definitions.set(name, alias);
1203
+ });
879
1204
  });
1205
+ const unassigned = declaredConstants.filter(
1206
+ (name) => !constants.has(name) && !substitutions.has(name) && !operatorKeys.has(name),
1207
+ );
1208
+ if (unassigned.length > 0 && !options.isUnconfigured) {
1209
+ // TLC reports the first constant it finds unassigned in SANY's order of declarations.
1210
+ const name =
1211
+ getTlcDeclarationOrder(options.source, options.loadModule, "constant").find((constant) =>
1212
+ unassigned.includes(constant),
1213
+ ) ?? unassigned[0];
1214
+ throw new TlaConfigError(
1215
+ `The constant parameter ${name} is not assigned a value by the configuration file.`,
1216
+ );
1217
+ }
1218
+
1219
+ if (options.isTraceRecorded) {
1220
+ builtins.forEach((builtin, name) => {
1221
+ const replacement = getTraceSpecArithmetic(builtin);
1222
+ if (replacement) builtins.set(name, replacement);
1223
+ });
1224
+ }
880
1225
 
881
1226
  const environment: Environment = {
882
1227
  runtime,
@@ -884,6 +1229,7 @@ export const createEnvironment = (
884
1229
  builtins,
885
1230
  constants,
886
1231
  substitutions,
1232
+ instanceNames,
887
1233
  variables,
888
1234
  variableIndex: getVariableIndex(
889
1235
  variables,
@@ -891,38 +1237,73 @@ export const createEnvironment = (
891
1237
  ),
892
1238
  definitionValues: new Map(),
893
1239
  constantLevels: new Map(),
1240
+ substitutedDefinitions,
894
1241
  evaluators: new WeakMap(),
895
1242
  };
896
- checkInstances(instanceChecks, (name) => {
897
- const linked = linkedModules.get(name) ?? nestedModules.get(name) ?? linkedRoot;
898
- return {
899
- constants: linked.constants,
900
- variables: linked.variables,
901
- definitions: [
902
- ...new Set(
903
- [...linked.visible.values()].flatMap((symbol) => definitions.get(symbol.key) ?? []),
904
- ),
905
- ],
906
- assumptions: linked.module.assumptions.map((assumption) => assumption.expression),
907
- getDefinition: (symbol) => definitions.get(linked.visible.get(symbol)?.key ?? symbol),
908
- };
1243
+ // TLC evaluates a substitute at startup and rejects it only when that fails and the level bound it
1244
+ // computes is above constant. The bound counts the operators that TLC's Java code overrides with
1245
+ // a minimum level as state-level, so the analyzer takes them for variables.
1246
+ const analyzer = createLevelAnalyzer({
1247
+ constants: new Set(constants.keys()),
1248
+ variables: new Set([
1249
+ ...variables,
1250
+ ...["TLCGet", "Trace", "CounterExample"].filter((name) => builtins.has(name)),
1251
+ ]),
1252
+ getDefinition: (name) => getDefinition(name, environment),
909
1253
  });
1254
+ const getEvaluationError = (body: Expression) => {
1255
+ try {
1256
+ evaluate(body, { environment, scope: undefined, state: undefined, next: undefined });
1257
+ return undefined;
1258
+ } catch (error) {
1259
+ if (error instanceof TlaEvaluationError) return error;
1260
+ throw error;
1261
+ }
1262
+ };
910
1263
  substitutions.forEach((target, name) => {
911
1264
  const definition = definitions.get(target);
912
- if (
1265
+ const error =
913
1266
  declaredConstants.includes(name) &&
914
- definition &&
915
- !isConstantLevel(definition, environment)
916
- ) {
1267
+ definition?.kind === "Operator" &&
1268
+ definition.params.length === 0 &&
1269
+ analyzer.analyzeDefinition(definition, new Map()).level > 0
1270
+ ? getEvaluationError(definition.body)
1271
+ : undefined;
1272
+ if (error) {
1273
+ // TLC's SpecProcessor adds the message of a TLCRuntimeException, not of an EvalException.
1274
+ const addendum = isEvalException(error) ? "" : ` - specifically: ${error.message}`;
917
1275
  throw new TlaConfigError(
918
- `The configuration file substitutes constant ${name} with non-constant ${target}`,
1276
+ `The configuration file substitutes constant ${name} with non-constant ${target}${addendum}`,
919
1277
  );
920
1278
  }
921
1279
  });
1280
+ // TLC 1.7.4 processes the whole spec before it creates its model checker, which TLCGet reads.
1281
+ if (runtime.version !== "1.7.4") runtime.isStarted = true;
1282
+ // TLC computes the constant definitions of each module in the order SANY finishes the modules,
1283
+ // except those of a module that an INSTANCE gives parameters to.
1284
+ const instantiated = new Set(
1285
+ linkedList.flatMap((linked) => linked.module.instances.map((instance) => instance.module)),
1286
+ );
1287
+ const getDefinitionOrder = createTlcDefinitionOrder(options.source, options.loadModule);
922
1288
  return {
923
1289
  environment,
924
1290
  assumptions,
925
1291
  variableLocations: linkedRoot.variableLocations,
926
1292
  instanceActions,
1293
+ startupDefinitions: linkedList
1294
+ .filter(
1295
+ (linked) => !instantiated.has(linked.module.name) || getDeclarations(linked).length === 0,
1296
+ )
1297
+ .flatMap((linked) =>
1298
+ getDefinitionOrder(linked === linkedRoot ? undefined : linked.module.name).flatMap(
1299
+ (name) => {
1300
+ const definition = definitions.get(linked.visible.get(name)?.key ?? name);
1301
+ return definition ? [definition] : [];
1302
+ },
1303
+ ),
1304
+ ),
1305
+ rootConstants: linkedRoot.constants,
1306
+ rootSymbols: linkedRoot.visible,
1307
+ javaOverrides: linkedList.flatMap((linked) => javaOverrides.get(linked.module.name) ?? []),
927
1308
  };
928
1309
  };