tla-ts 0.0.3-dev.07eab97 → 0.0.3-dev.0ad0249

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 (80) hide show
  1. package/dist/cli.cjs +1 -1
  2. package/dist/cli.js +1 -1
  3. package/dist/index.cjs +1 -1
  4. package/dist/index.d.cts +160 -46
  5. package/dist/index.d.ts +160 -46
  6. package/dist/index.js +1 -1
  7. package/dist/parallel-worker.cjs +1 -1
  8. package/dist/parallel-worker.js +2 -2
  9. package/dist/parallel.cjs +1 -1
  10. package/dist/parallel.js +2 -2
  11. package/dist/run-cli.cjs +1351 -22
  12. package/dist/run-cli.js +1351 -22
  13. package/dist/transfer.cjs +83 -33
  14. package/dist/transfer.js +83 -33
  15. package/package.json +4 -1
  16. package/src/ast.ts +42 -5
  17. package/src/bags.ts +4 -7
  18. package/src/builtins.ts +29 -17
  19. package/src/bundled-modules.ts +3 -3
  20. package/src/canonical.ts +4 -3
  21. package/src/check.ts +1296 -429
  22. package/src/cli.ts +8 -1
  23. package/src/codegen.ts +68 -21
  24. package/src/config.ts +225 -206
  25. package/src/environment.ts +388 -115
  26. package/src/errors.ts +155 -18
  27. package/src/evaluate.ts +713 -259
  28. package/src/exit-codes.ts +6 -24
  29. package/src/fingerprints.ts +1 -2
  30. package/src/index.ts +1 -0
  31. package/src/instances.ts +3 -1
  32. package/src/java-overrides.ts +104 -25
  33. package/src/levels.ts +37 -27
  34. package/src/lexer.ts +14 -1
  35. package/src/live-check.ts +204 -148
  36. package/src/liveness.ts +191 -122
  37. package/src/obligation-expression.ts +2 -2
  38. package/src/obligation-source.ts +2 -0
  39. package/src/parallel-worker.ts +6 -1
  40. package/src/parallel.ts +57 -6
  41. package/src/parser.ts +369 -115
  42. package/src/pcal-ast.ts +770 -0
  43. package/src/pcal-parse.ts +1523 -0
  44. package/src/pcal-tokenize.ts +516 -0
  45. package/src/pcal-translate.ts +1230 -0
  46. package/src/pcal-validate.ts +454 -0
  47. package/src/randomization.ts +24 -7
  48. package/src/resolve.ts +1332 -453
  49. package/src/run-cli.ts +1161 -196
  50. package/src/runtime.ts +16 -0
  51. package/src/sany-builtins.ts +147 -0
  52. package/src/sany-generator.ts +3112 -0
  53. package/src/sany-levels.ts +1208 -0
  54. package/src/sany-lexer.ts +545 -0
  55. package/src/sany-linter.ts +122 -0
  56. package/src/sany-modules.ts +1398 -0
  57. package/src/sany-nodes.ts +463 -0
  58. package/src/sany-parse-error.ts +2161 -0
  59. package/src/sany-report.ts +354 -0
  60. package/src/sany-selectors.ts +738 -0
  61. package/src/sany-source.ts +248 -0
  62. package/src/sany-xml.ts +1017 -0
  63. package/src/spec-description.ts +25 -5
  64. package/src/standard-modules.ts +172 -129
  65. package/src/standard-ranges.ts +116 -0
  66. package/src/state-graph.ts +29 -6
  67. package/src/subexpressions.ts +221 -161
  68. package/src/successors.ts +141 -173
  69. package/src/symmetry.ts +168 -50
  70. package/src/tableau.ts +3 -1
  71. package/src/tlc-ext.ts +13 -17
  72. package/src/tlc-messages.ts +329 -0
  73. package/src/tlc-module.ts +49 -21
  74. package/src/tlc-modules.ts +0 -4
  75. package/src/tlc-order.ts +55 -9
  76. package/src/tlc-random.ts +28 -3
  77. package/src/tlc-replay.ts +655 -0
  78. package/src/tlc-version.ts +18 -0
  79. package/src/transfer.ts +15 -3
  80. package/src/values.ts +664 -317
@@ -14,10 +14,13 @@ import type { ConfigValue, ModelConfig } from "./config";
14
14
  import type { FileSystem } from "./json";
15
15
  import {
16
16
  createSanyError,
17
+ createMissingModuleError,
18
+ formatRange,
19
+ formatSanyWarnings,
17
20
  TlaConfigError,
18
21
  TlaEvaluationError,
19
- TlaModuleError,
20
22
  TlaSyntaxError,
23
+ type SanyError,
21
24
  } from "./errors";
22
25
  import { EXIT_STATUS, setExitCode } from "./exit-codes";
23
26
  import {
@@ -35,25 +38,39 @@ import {
35
38
  renameLocals,
36
39
  withLetInstances,
37
40
  } from "./instances";
38
- import { overrideDefinitions } from "./java-overrides";
41
+ import { overrideDefinitions, type JavaOverride } from "./java-overrides";
39
42
  import { extractModule, parseModule } from "./parser";
40
43
  import {
41
- checkRedefinitions,
42
44
  getArity,
45
+ getParamArities,
43
46
  isBefore,
47
+ isTheoremDefinition,
44
48
  KEY_SEPARATOR,
45
49
  LOCAL_RESOLUTION,
50
+ MODULE_START,
46
51
  resolveModule,
47
52
  resolveSubstitutions,
53
+ type ModuleReport,
48
54
  type ModuleSymbol,
55
+ type ModuleUnit,
56
+ type SymbolKind,
49
57
  type Symbols,
50
58
  } from "./resolve";
51
59
  import { createRuntime } from "./runtime";
52
- 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";
53
69
  import { resolveInstanceSubexpressions, resolveModuleSubexpressions } from "./subexpressions";
54
70
  import { checkModuleLevels, createLevelAnalyzer } from "./levels";
55
71
  import { createInstanceChecker, type InstanceCheck } from "./substitution-levels";
56
- import { getTlcDeclarationOrder } from "./tlc-order";
72
+ import { isEvalException } from "./tlc-messages";
73
+ import { createTlcDefinitionOrder, getTlcDeclarationOrder } from "./tlc-order";
57
74
  import {
58
75
  checkInteger,
59
76
  createModelValue,
@@ -61,7 +78,9 @@ import {
61
78
  formatValue,
62
79
  valuesEqual,
63
80
  type Value,
81
+ markNormalized,
64
82
  } from "./values";
83
+ import type { TlcVersion } from "./tlc-version";
65
84
 
66
85
  interface EnvironmentOptions {
67
86
  source: string;
@@ -70,6 +89,15 @@ interface EnvironmentOptions {
70
89
  print: (text: string) => void;
71
90
  files: FileSystem;
72
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;
73
101
  }
74
102
 
75
103
  interface Specification {
@@ -77,6 +105,12 @@ interface Specification {
77
105
  assumptions: Assumption[];
78
106
  variableLocations: SourceLocation[];
79
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[];
80
114
  }
81
115
 
82
116
  export interface InstanceAction {
@@ -112,25 +146,73 @@ interface LinkedModule {
112
146
  exported: Symbols;
113
147
  modules: Map<string, LinkedModule>;
114
148
  extended: LinkedModule[];
149
+ facts: Set<string>;
115
150
  }
116
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.
117
154
  interface ModuleScope {
118
155
  id: string;
119
156
  symbols: Symbols;
120
157
  modules: Map<string, LinkedModule>;
121
158
  nested: Module[];
159
+ errors: SanyError[];
160
+ warnings: SanyError[];
161
+ levelChecks: (() => void)[];
122
162
  }
123
163
 
124
- const getDeclarations = (linked: LinkedModule) => [
164
+ const getDeclarations = (linked: LinkedModule): Declaration[] => [
125
165
  ...linked.constants,
126
- ...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
+ })),
127
171
  ];
128
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
+
129
195
  const createModuleRedefinedError = (module: Module) =>
130
196
  new TlaSyntaxError(
131
197
  `Multiply-defined module '${module.name}' at line ${module.location.line}, column ${module.location.column}`,
132
198
  );
133
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
+
134
216
  const createLocalFunction = (definition: Definition, key: string): Definition => ({
135
217
  kind: "Operator",
136
218
  name: key,
@@ -222,11 +304,15 @@ export const createEnvironment = (
222
304
  const parameterized = new Map<string, boolean>();
223
305
  // The definition each instance copy came from, and the instance parameters the copy adds.
224
306
  const copySources = new Map<string, { source: string; prefix: number }>();
307
+ const substitutedDefinitions = new Set<Definition>();
225
308
  const builtins = new Map<string, Builtin>(
226
309
  CORE_OPERATORS.map((operator) => [operator.name, operator]),
227
310
  );
228
311
  const standardExports = new Map<string, Symbols>();
229
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";
230
316
  const linkedModules = new Map<string, LinkedModule>();
231
317
  const nestedModules = new Map<string, LinkedModule>();
232
318
  // Each module by name, from the time its level checks run.
@@ -245,6 +331,8 @@ export const createEnvironment = (
245
331
  const copyCount = { value: 0 };
246
332
  const createName = (name: string) => `${name}#${copyCount.value++}`;
247
333
  const instanceChecks: InstanceCheck[] = [];
334
+ // The warnings SANY reports for the spec.
335
+ const warnings: SanyError[] = [];
248
336
  const checkInstance = createInstanceChecker((name) => {
249
337
  const linked = checkedModules.get(name) ?? getLinkedModule(name, name);
250
338
  return {
@@ -261,13 +349,17 @@ export const createEnvironment = (
261
349
  };
262
350
  });
263
351
  const instanceActions = new Map<string, InstanceAction>();
352
+ const instanceNames = new Map<string, string>();
264
353
  const qualifiedNames = new Map<string, string>();
265
354
 
266
355
  const addStandardModule = (name: string): Symbols | undefined => {
267
356
  const cached = standardExports.get(name);
268
357
  if (cached) return cached;
269
- const standardModule = getStandardModule(name, options.print, runtime, options.files);
358
+ const standardModule = getStandardModule(name, options.print, runtime, options.files, builtins);
270
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);
271
363
  const exported: Symbols = new Map();
272
364
  standardModule.extends.forEach((extended) =>
273
365
  addStandardModule(extended)?.forEach((symbol, symbolName) =>
@@ -276,7 +368,13 @@ export const createEnvironment = (
276
368
  );
277
369
  standardModule.operators.forEach((operator) => {
278
370
  builtins.set(operator.name, operator);
279
- 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
+ });
280
378
  });
281
379
  standardExports.set(name, exported);
282
380
  return exported;
@@ -316,17 +414,8 @@ export const createEnvironment = (
316
414
  options.loadModule?.(name) ??
317
415
  BUNDLED_MODULES.get(name) ??
318
416
  extractModule(options.source, name);
319
- if (source === undefined)
320
- throw createSanyError(
321
- [
322
- {
323
- location: `In module ${importer}`,
324
- message: `Cannot find source file for module ${name} imported in module ${importer}.`,
325
- },
326
- ],
327
- true,
328
- );
329
- const module = parseModule(source);
417
+ if (source === undefined) throw createMissingModuleError(name, importer);
418
+ const module = parseModuleFile(source, name);
330
419
  if (module.name !== name) {
331
420
  throw createSanyError(
332
421
  [
@@ -351,6 +440,8 @@ export const createEnvironment = (
351
440
  }
352
441
  const closure = new Set<string>();
353
442
  const nested: Module[] = [];
443
+ const errors: SanyError[] = [];
444
+ const levelChecks: (() => void)[] = [];
354
445
  linking.push(parsed.name);
355
446
  loading.push(closure);
356
447
  const linked = linkModule(parsed, {
@@ -358,11 +449,19 @@ export const createEnvironment = (
358
449
  symbols: new Map(),
359
450
  modules: new Map(),
360
451
  nested,
452
+ errors,
453
+ warnings,
454
+ levelChecks,
361
455
  });
362
456
  loading.pop();
363
457
  linking.pop();
458
+ if (errors.length > 0) throw createSanyError(errors, false, undefined, warnings);
364
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);
365
463
  if (duplicate) throw createModuleRedefinedError(duplicate);
464
+ levelChecks.forEach((check) => check());
366
465
  return { linked, closure };
367
466
  };
368
467
 
@@ -382,23 +481,16 @@ export const createEnvironment = (
382
481
  const instantiate = (
383
482
  instance: Instance,
384
483
  module: Module,
385
- unit: {
386
- imported: Symbols;
387
- importedAt: Map<string, SourceLocation>;
388
- definitions: Map<string, Definition>;
389
- getKey: (definition: Definition) => string;
390
- },
484
+ unit: ModuleUnit,
391
485
  isParameterFree: boolean,
392
486
  nested: LinkedModule | undefined,
393
487
  ): Symbols => {
394
488
  const standardSymbols = nested ? undefined : getStandardSymbols(instance.module);
395
- if (standardSymbols) {
396
- if (instance.name === undefined) return standardSymbols;
397
- return new Map(
398
- [...standardSymbols].map(([name, symbol]) => [`${instance.name}!${name}`, symbol]),
399
- );
400
- }
489
+ if (standardSymbols) return getStandardInstanceSymbols(instance, standardSymbols);
401
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
+ );
402
494
  const declarations = getDeclarations(linked);
403
495
  const suffix = `#${copyCount.value++}`;
404
496
  const renamed = new Map(instance.params.map((param) => [param.name, `${param.name}${suffix}`]));
@@ -425,35 +517,81 @@ export const createEnvironment = (
425
517
  isParameterized: (key) => parameterized.get(key) === true,
426
518
  addDefinition: (source, name, create) => {
427
519
  const key = createName(`${name}@${module.name}`);
428
- 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
+ }
429
526
  parameterized.set(key, !isParameterFree);
430
527
  copySources.set(key, { source, prefix: instance.params.length });
431
528
  return key;
432
529
  },
433
530
  createName,
434
531
  });
435
- const declared = new Set(declarations.map((declaration) => declaration.name));
436
- const symbols: Symbols = new Map();
437
- linked.exported.forEach((symbol, name) => {
438
- if (declared.has(name)) return;
439
- if (instance.name === undefined) {
440
- const key = instantiation.getKey(symbol.key);
441
- if (declarations.length > 0)
442
- instanceActions.set(key, { name, location: instance.location });
443
- symbols.set(name, { key, arity: symbol.arity });
444
- return;
445
- }
446
- const key = instantiation.getQualifiedKey(symbol.key);
447
- if (declarations.length > 0) {
448
- instanceActions.set(key, { name: `${instance.name}!${name}`, location: instance.location });
449
- }
450
- qualifiedNames.set(key, `${instance.name}!${name}`);
451
- symbols.set(`${instance.name}!${name}`, {
452
- key,
453
- arity: symbol.arity + instance.params.length,
454
- });
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;
455
540
  });
456
- 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
+ );
457
595
  };
458
596
 
459
597
  const getLocalArguments = (params: OperatorParam[], location: SourceLocation) =>
@@ -626,32 +764,70 @@ export const createEnvironment = (
626
764
  return definition ? [{ ...definition, name }] : [];
627
765
  });
628
766
 
767
+ const javaOverrides = new Map<string, JavaOverride[]>();
629
768
  const linkModule = (unlinked: Module, scope: ModuleScope): LinkedModule => {
630
- 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;
631
776
  const firstCheck = instanceChecks.length;
632
777
  const visible: Symbols = new Map([
633
778
  ...CORE_OPERATORS.map((operator): [string, ModuleSymbol] => [
634
779
  operator.name,
635
- { key: operator.name, arity: operator.arity },
780
+ { key: operator.name, arity: operator.arity, kind: "Builtin" },
636
781
  ]),
637
782
  ...scope.symbols,
638
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
+ });
639
819
  const exported: Symbols = new Map();
820
+ const facts = new Set<string>();
640
821
  const modules = new Map<string, LinkedModule>();
641
822
  const extended: LinkedModule[] = [];
642
823
  const constants = [...parsed.constants];
643
824
  const variables = parsed.variables.map((variable) => variable.name);
644
825
  const variableLocations = parsed.variables.map((variable) => variable.location);
645
- const addSymbols = (symbols: Symbols, isExported: boolean) =>
646
- symbols.forEach((symbol, name) => {
647
- visible.set(name, symbol);
648
- if (isExported) exported.set(name, symbol);
649
- });
650
826
  parsed.extends.forEach((name) => {
651
827
  const nested = scope.modules.get(name);
652
828
  const standardSymbols = nested ? undefined : getStandardSymbols(name);
653
829
  if (standardSymbols) {
654
- addSymbols(standardSymbols, true);
830
+ mergeExtended(standardSymbols);
655
831
  return;
656
832
  }
657
833
  const linked = nested ?? getLinkedModule(name, parsed.name);
@@ -665,61 +841,114 @@ export const createEnvironment = (
665
841
  variables.push(variable);
666
842
  variableLocations.push(linked.variableLocations[index]);
667
843
  });
668
- addSymbols(linked.exported, true);
844
+ mergeExtended(linked.exported);
845
+ linked.facts.forEach((name) => facts.add(name));
669
846
  linked.modules.forEach((module, moduleName) => modules.set(moduleName, module));
670
847
  extended.push(linked);
671
848
  });
672
- parsed.constants.forEach((constant) =>
673
- exported.set(constant.name, {
674
- key: constant.name,
675
- arity: constant.arity,
676
- declaration: "Constant",
677
- }),
678
- );
679
- parsed.variables.forEach((variable) =>
680
- 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)),
681
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
+ });
682
870
  const isParameterFree = constants.length === 0 && variables.length === 0;
683
871
  const getKey = (definition: Definition) =>
684
872
  parsed === root ? definition.name : `${definition.name}${KEY_SEPARATOR}${scope.id}`;
685
- const importedAt = new Map<string, SourceLocation>();
686
- 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 => ({
687
885
  imported: visible,
688
- importedAt,
689
- 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
+ ),
690
909
  getKey,
910
+ instanced,
911
+ facts,
912
+ reports,
913
+ warnings: scope.warnings,
691
914
  });
692
- const getVisibleModules = () => new Map([...scope.modules, ...modules]);
693
915
  const getSymbolsBefore = (location: SourceLocation): Symbols =>
694
916
  new Map([
695
917
  ...visible,
696
- ...[
697
- ...parsed.constants.map((constant) => ({ ...constant, kind: "Constant" as const })),
698
- ...parsed.variables.map((variable) => ({ ...variable, kind: "Variable" as const })),
699
- ]
918
+ ...declarations
700
919
  .filter((declaration) => isBefore(declaration.location, location))
701
920
  .map((declaration): [string, ModuleSymbol] => [
702
921
  declaration.name,
703
- { key: declaration.name, arity: declaration.arity, declaration: declaration.kind },
922
+ getDeclarationSymbol(declaration),
704
923
  ]),
705
924
  ...parsed.definitions
706
925
  .filter((definition) => isBefore(definition.location, location))
707
926
  .map((definition): [string, ModuleSymbol] => [
708
927
  definition.name,
709
- { key: getKey(definition), arity: getArity(definition) },
928
+ getDefinitionSymbol(definition),
710
929
  ]),
711
930
  ]);
931
+ // Generator.generateModule reports the errors of a nested module and goes on, and then
932
+ // SymbolTable.addModule reports a module already defined.
712
933
  const linkNested = (nested: Module) => {
713
934
  const visibleModules = getVisibleModules();
714
- 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);
715
938
  scope.nested.push(nested);
939
+ const report: ModuleReport = { location: nested.location, errors: [], warnings: [] };
940
+ reports.push(report);
716
941
  const linked = linkModule(nested, {
717
942
  id: `${scope.id}/${nested.name}`,
718
943
  symbols: getSymbolsBefore(nested.location),
719
944
  modules: visibleModules,
720
945
  nested: scope.nested,
946
+ errors: report.errors,
947
+ warnings: report.warnings,
948
+ levelChecks: scope.levelChecks,
721
949
  });
722
- modules.set(nested.name, linked);
950
+ if (redefinition) report.errors.push(redefinition);
951
+ if (!existing) modules.set(nested.name, linked);
723
952
  if (!nestedModules.has(nested.name)) nestedModules.set(nested.name, linked);
724
953
  };
725
954
  [
@@ -733,10 +962,13 @@ export const createEnvironment = (
733
962
  isParameterFree,
734
963
  getVisibleModules().get(instance.module),
735
964
  );
736
- symbols.forEach((_, name) => {
737
- 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);
738
971
  });
739
- addSymbols(symbols, !instance.isLocal);
740
972
  },
741
973
  })),
742
974
  ...parsed.modules.map((nested) => ({
@@ -746,28 +978,27 @@ export const createEnvironment = (
746
978
  ]
747
979
  .sort((left, right) => (isBefore(left.location, right.location) ? -1 : 1))
748
980
  .forEach((unit) => unit.link());
749
- checkRedefinitions(parsed, getUnit(parsed));
750
- const isInstancedAfterDefinition = (nested: Module) => {
751
- const first = parsed.instances.find((instance) => instance.module === nested.name);
752
- return first !== undefined && isBefore(nested.location, first.location);
753
- };
754
- const getLetModule = (instance: Instance) => {
755
- const own = parsed.modules.find((nested) => nested.name === instance.module);
756
- if (!own) return getVisibleModules().get(instance.module);
757
- return isInstancedAfterDefinition(own) ? modules.get(own.name) : undefined;
758
- };
759
981
  const module = resolveModuleSubexpressions(
760
982
  withLetInstances(parsed, (instance, lets) =>
761
983
  instantiateLocally(instance, lets, parsed.name, getLetModule(instance)),
762
984
  ),
763
985
  getAvailableDefinitions(visible),
764
986
  );
765
- resolveModule(module, getUnit(module));
987
+ scope.errors.push(...resolveModule(module, getUnit(module)));
766
988
  module.definitions.forEach((definition) => {
767
989
  const key = getKey(definition);
768
990
  definitions.set(key, definition);
769
991
  parameterized.set(key, !isParameterFree);
770
- 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
+ }
771
1002
  visible.set(definition.name, symbol);
772
1003
  if (!definition.isLocal) exported.set(definition.name, symbol);
773
1004
  });
@@ -780,27 +1011,36 @@ export const createEnvironment = (
780
1011
  exported,
781
1012
  modules,
782
1013
  extended,
1014
+ facts: new Set([
1015
+ ...facts,
1016
+ ...[...module.theorems, ...module.assumptions].flatMap((fact) => fact.name ?? []),
1017
+ ]),
783
1018
  };
784
1019
  if (!checkedModules.has(parsed.name)) checkedModules.set(parsed.name, linked);
785
1020
  // SANY checks the instances of a module with its definitions and theorems, so it reports their
786
1021
  // errors together.
787
- checkModuleLevels(
788
- module,
789
- {
790
- constants: new Set(constants.map((constant) => constant.name)),
791
- variables: new Set(variables),
792
- getDefinition: (symbol) => definitions.get(visible.get(symbol)?.key ?? symbol),
793
- getQualifiedName: (symbol) => qualifiedNames.get(visible.get(symbol)?.key ?? symbol),
794
- },
795
- instanceChecks
796
- .splice(firstCheck)
797
- .map((check) => ({ location: check.location, check: () => checkInstance(check) })),
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
+ ),
798
1037
  );
799
1038
  linkedList.push(linked);
800
1039
  return linked;
801
1040
  };
802
1041
 
803
1042
  const linkedRoot = linkTopLevel(root).linked;
1043
+ if (warnings.length > 0 && !options.isSanyReported) options.print(formatSanyWarnings(warnings));
804
1044
  const getRootKey = (name: string) => linkedRoot.visible.get(name)?.key ?? name;
805
1045
  linkedRoot.visible.forEach((symbol, name) => {
806
1046
  const definition = definitions.get(symbol.key);
@@ -842,6 +1082,7 @@ export const createEnvironment = (
842
1082
  .filter((assignment) => assignment.args === undefined)
843
1083
  .forEach((assignment) => {
844
1084
  const value = toValue(assignment.value);
1085
+ markNormalized(value);
845
1086
  getScopedKeys(assignment).forEach((key) => {
846
1087
  const arity = getKeyArity(key);
847
1088
  if (arity === 0) constants.set(key, value);
@@ -964,7 +1205,7 @@ export const createEnvironment = (
964
1205
  const unassigned = declaredConstants.filter(
965
1206
  (name) => !constants.has(name) && !substitutions.has(name) && !operatorKeys.has(name),
966
1207
  );
967
- if (unassigned.length > 0) {
1208
+ if (unassigned.length > 0 && !options.isUnconfigured) {
968
1209
  // TLC reports the first constant it finds unassigned in SANY's order of declarations.
969
1210
  const name =
970
1211
  getTlcDeclarationOrder(options.source, options.loadModule, "constant").find((constant) =>
@@ -975,12 +1216,20 @@ export const createEnvironment = (
975
1216
  );
976
1217
  }
977
1218
 
1219
+ if (options.isTraceRecorded) {
1220
+ builtins.forEach((builtin, name) => {
1221
+ const replacement = getTraceSpecArithmetic(builtin);
1222
+ if (replacement) builtins.set(name, replacement);
1223
+ });
1224
+ }
1225
+
978
1226
  const environment: Environment = {
979
1227
  runtime,
980
1228
  definitions,
981
1229
  builtins,
982
1230
  constants,
983
1231
  substitutions,
1232
+ instanceNames,
984
1233
  variables,
985
1234
  variableIndex: getVariableIndex(
986
1235
  variables,
@@ -988,6 +1237,7 @@ export const createEnvironment = (
988
1237
  ),
989
1238
  definitionValues: new Map(),
990
1239
  constantLevels: new Map(),
1240
+ substitutedDefinitions,
991
1241
  evaluators: new WeakMap(),
992
1242
  };
993
1243
  // TLC evaluates a substitute at startup and rejects it only when that fails and the level bound it
@@ -1019,18 +1269,41 @@ export const createEnvironment = (
1019
1269
  analyzer.analyzeDefinition(definition, new Map()).level > 0
1020
1270
  ? getEvaluationError(definition.body)
1021
1271
  : undefined;
1022
- // TLC adds the reason unless a standard module's Java code failed.
1023
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}`;
1024
1275
  throw new TlaConfigError(
1025
- `The configuration file substitutes constant ${name} with non-constant ${target}${error instanceof TlaModuleError ? "" : ` - specifically: ${error.message}`}`,
1276
+ `The configuration file substitutes constant ${name} with non-constant ${target}${addendum}`,
1026
1277
  );
1027
1278
  }
1028
1279
  });
1029
- runtime.isStarted = true;
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);
1030
1288
  return {
1031
1289
  environment,
1032
1290
  assumptions,
1033
1291
  variableLocations: linkedRoot.variableLocations,
1034
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) ?? []),
1035
1308
  };
1036
1309
  };