tla-ts 0.0.3-dev.c8c988d → 0.0.3-dev.ccbff8c

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (81) hide show
  1. package/dist/cli.cjs +1 -1
  2. package/dist/cli.js +1 -1
  3. package/dist/index.cjs +1 -1
  4. package/dist/index.d.cts +163 -46
  5. package/dist/index.d.ts +163 -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 +5 -1
  16. package/src/ast.ts +51 -6
  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 +1317 -428
  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 +417 -129
  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 +44 -28
  34. package/src/lexer.ts +32 -4
  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 +405 -167
  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 +1397 -457
  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/substitution-levels.ts +5 -8
  69. package/src/successors.ts +141 -173
  70. package/src/symmetry.ts +168 -50
  71. package/src/tableau.ts +3 -1
  72. package/src/tlc-ext.ts +13 -17
  73. package/src/tlc-messages.ts +329 -0
  74. package/src/tlc-module.ts +49 -21
  75. package/src/tlc-modules.ts +0 -4
  76. package/src/tlc-order.ts +55 -9
  77. package/src/tlc-random.ts +28 -3
  78. package/src/tlc-replay.ts +655 -0
  79. package/src/tlc-version.ts +18 -0
  80. package/src/transfer.ts +15 -3
  81. 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
- import { checkInstances, type InstanceCheck } from "./substitution-levels";
56
- import { getTlcDeclarationOrder } from "./tlc-order";
71
+ import { createInstanceChecker, type InstanceCheck } from "./substitution-levels";
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,13 +304,19 @@ 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>();
318
+ // Each module by name, from the time its level checks run.
319
+ const checkedModules = new Map<string, LinkedModule>();
232
320
  const linkedList: LinkedModule[] = [];
233
321
  const dependencies = new Map<string, Set<string>>();
234
322
  const loading: Set<string>[] = [];
@@ -243,14 +331,35 @@ export const createEnvironment = (
243
331
  const copyCount = { value: 0 };
244
332
  const createName = (name: string) => `${name}#${copyCount.value++}`;
245
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
+ });
246
351
  const instanceActions = new Map<string, InstanceAction>();
352
+ const instanceNames = new Map<string, string>();
247
353
  const qualifiedNames = new Map<string, string>();
248
354
 
249
355
  const addStandardModule = (name: string): Symbols | undefined => {
250
356
  const cached = standardExports.get(name);
251
357
  if (cached) return cached;
252
- const standardModule = getStandardModule(name, options.print, runtime, options.files);
358
+ const standardModule = getStandardModule(name, options.print, runtime, options.files, builtins);
253
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);
254
363
  const exported: Symbols = new Map();
255
364
  standardModule.extends.forEach((extended) =>
256
365
  addStandardModule(extended)?.forEach((symbol, symbolName) =>
@@ -259,7 +368,13 @@ export const createEnvironment = (
259
368
  );
260
369
  standardModule.operators.forEach((operator) => {
261
370
  builtins.set(operator.name, operator);
262
- 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
+ });
263
378
  });
264
379
  standardExports.set(name, exported);
265
380
  return exported;
@@ -299,17 +414,8 @@ export const createEnvironment = (
299
414
  options.loadModule?.(name) ??
300
415
  BUNDLED_MODULES.get(name) ??
301
416
  extractModule(options.source, name);
302
- if (source === undefined)
303
- throw createSanyError(
304
- [
305
- {
306
- location: `In module ${importer}`,
307
- message: `Cannot find source file for module ${name} imported in module ${importer}.`,
308
- },
309
- ],
310
- true,
311
- );
312
- const module = parseModule(source);
417
+ if (source === undefined) throw createMissingModuleError(name, importer);
418
+ const module = parseModuleFile(source, name);
313
419
  if (module.name !== name) {
314
420
  throw createSanyError(
315
421
  [
@@ -334,6 +440,8 @@ export const createEnvironment = (
334
440
  }
335
441
  const closure = new Set<string>();
336
442
  const nested: Module[] = [];
443
+ const errors: SanyError[] = [];
444
+ const levelChecks: (() => void)[] = [];
337
445
  linking.push(parsed.name);
338
446
  loading.push(closure);
339
447
  const linked = linkModule(parsed, {
@@ -341,11 +449,19 @@ export const createEnvironment = (
341
449
  symbols: new Map(),
342
450
  modules: new Map(),
343
451
  nested,
452
+ errors,
453
+ warnings,
454
+ levelChecks,
344
455
  });
345
456
  loading.pop();
346
457
  linking.pop();
458
+ if (errors.length > 0) throw createSanyError(errors, false, undefined, warnings);
347
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);
348
463
  if (duplicate) throw createModuleRedefinedError(duplicate);
464
+ levelChecks.forEach((check) => check());
349
465
  return { linked, closure };
350
466
  };
351
467
 
@@ -365,23 +481,16 @@ export const createEnvironment = (
365
481
  const instantiate = (
366
482
  instance: Instance,
367
483
  module: Module,
368
- unit: {
369
- imported: Symbols;
370
- importedAt: Map<string, SourceLocation>;
371
- definitions: Map<string, Definition>;
372
- getKey: (definition: Definition) => string;
373
- },
484
+ unit: ModuleUnit,
374
485
  isParameterFree: boolean,
375
486
  nested: LinkedModule | undefined,
376
487
  ): Symbols => {
377
488
  const standardSymbols = nested ? undefined : getStandardSymbols(instance.module);
378
- if (standardSymbols) {
379
- if (instance.name === undefined) return standardSymbols;
380
- return new Map(
381
- [...standardSymbols].map(([name, symbol]) => [`${instance.name}!${name}`, symbol]),
382
- );
383
- }
489
+ if (standardSymbols) return getStandardInstanceSymbols(instance, standardSymbols);
384
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
+ );
385
494
  const declarations = getDeclarations(linked);
386
495
  const suffix = `#${copyCount.value++}`;
387
496
  const renamed = new Map(instance.params.map((param) => [param.name, `${param.name}${suffix}`]));
@@ -408,35 +517,81 @@ export const createEnvironment = (
408
517
  isParameterized: (key) => parameterized.get(key) === true,
409
518
  addDefinition: (source, name, create) => {
410
519
  const key = createName(`${name}@${module.name}`);
411
- 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
+ }
412
526
  parameterized.set(key, !isParameterFree);
413
527
  copySources.set(key, { source, prefix: instance.params.length });
414
528
  return key;
415
529
  },
416
530
  createName,
417
531
  });
418
- const declared = new Set(declarations.map((declaration) => declaration.name));
419
- const symbols: Symbols = new Map();
420
- linked.exported.forEach((symbol, name) => {
421
- if (declared.has(name)) return;
422
- if (instance.name === undefined) {
423
- const key = instantiation.getKey(symbol.key);
424
- if (declarations.length > 0)
425
- instanceActions.set(key, { name, location: instance.location });
426
- symbols.set(name, { key, arity: symbol.arity });
427
- return;
428
- }
429
- const key = instantiation.getQualifiedKey(symbol.key);
430
- if (declarations.length > 0) {
431
- instanceActions.set(key, { name: `${instance.name}!${name}`, location: instance.location });
432
- }
433
- qualifiedNames.set(key, `${instance.name}!${name}`);
434
- symbols.set(`${instance.name}!${name}`, {
435
- key,
436
- arity: symbol.arity + instance.params.length,
437
- });
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;
438
540
  });
439
- 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
+ );
440
595
  };
441
596
 
442
597
  const getLocalArguments = (params: OperatorParam[], location: SourceLocation) =>
@@ -609,31 +764,70 @@ export const createEnvironment = (
609
764
  return definition ? [{ ...definition, name }] : [];
610
765
  });
611
766
 
767
+ const javaOverrides = new Map<string, JavaOverride[]>();
612
768
  const linkModule = (unlinked: Module, scope: ModuleScope): LinkedModule => {
613
- 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;
614
777
  const visible: Symbols = new Map([
615
778
  ...CORE_OPERATORS.map((operator): [string, ModuleSymbol] => [
616
779
  operator.name,
617
- { key: operator.name, arity: operator.arity },
780
+ { key: operator.name, arity: operator.arity, kind: "Builtin" },
618
781
  ]),
619
782
  ...scope.symbols,
620
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
+ });
621
819
  const exported: Symbols = new Map();
820
+ const facts = new Set<string>();
622
821
  const modules = new Map<string, LinkedModule>();
623
822
  const extended: LinkedModule[] = [];
624
823
  const constants = [...parsed.constants];
625
824
  const variables = parsed.variables.map((variable) => variable.name);
626
825
  const variableLocations = parsed.variables.map((variable) => variable.location);
627
- const addSymbols = (symbols: Symbols, isExported: boolean) =>
628
- symbols.forEach((symbol, name) => {
629
- visible.set(name, symbol);
630
- if (isExported) exported.set(name, symbol);
631
- });
632
826
  parsed.extends.forEach((name) => {
633
827
  const nested = scope.modules.get(name);
634
828
  const standardSymbols = nested ? undefined : getStandardSymbols(name);
635
829
  if (standardSymbols) {
636
- addSymbols(standardSymbols, true);
830
+ mergeExtended(standardSymbols);
637
831
  return;
638
832
  }
639
833
  const linked = nested ?? getLinkedModule(name, parsed.name);
@@ -647,61 +841,117 @@ export const createEnvironment = (
647
841
  variables.push(variable);
648
842
  variableLocations.push(linked.variableLocations[index]);
649
843
  });
650
- addSymbols(linked.exported, true);
844
+ mergeExtended(linked.exported);
845
+ linked.facts.forEach((name) => facts.add(name));
651
846
  linked.modules.forEach((module, moduleName) => modules.set(moduleName, module));
652
847
  extended.push(linked);
653
848
  });
654
- parsed.constants.forEach((constant) =>
655
- exported.set(constant.name, {
656
- key: constant.name,
657
- arity: constant.arity,
658
- declaration: "Constant",
659
- }),
660
- );
661
- parsed.variables.forEach((variable) =>
662
- 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)),
663
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
+ });
664
870
  const isParameterFree = constants.length === 0 && variables.length === 0;
665
871
  const getKey = (definition: Definition) =>
666
872
  parsed === root ? definition.name : `${definition.name}${KEY_SEPARATOR}${scope.id}`;
667
- const importedAt = new Map<string, SourceLocation>();
668
- 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 => ({
669
885
  imported: visible,
670
- importedAt,
671
- 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
+ ),
672
909
  getKey,
910
+ instanced,
911
+ facts,
912
+ reports,
913
+ warnings: scope.warnings,
673
914
  });
674
- const getVisibleModules = () => new Map([...scope.modules, ...modules]);
915
+ // SANY keeps the first of two symbols of a name.
675
916
  const getSymbolsBefore = (location: SourceLocation): Symbols =>
676
- new Map([
677
- ...visible,
678
- ...[
679
- ...parsed.constants.map((constant) => ({ ...constant, kind: "Constant" as const })),
680
- ...parsed.variables.map((variable) => ({ ...variable, kind: "Variable" as const })),
681
- ]
917
+ [
918
+ ...declarations
682
919
  .filter((declaration) => isBefore(declaration.location, location))
683
920
  .map((declaration): [string, ModuleSymbol] => [
684
921
  declaration.name,
685
- { key: declaration.name, arity: declaration.arity, declaration: declaration.kind },
922
+ getDeclarationSymbol(declaration),
686
923
  ]),
687
924
  ...parsed.definitions
688
925
  .filter((definition) => isBefore(definition.location, location))
689
926
  .map((definition): [string, ModuleSymbol] => [
690
927
  definition.name,
691
- { key: getKey(definition), arity: getArity(definition) },
928
+ getDefinitionSymbol(definition),
692
929
  ]),
693
- ]);
930
+ ].reduce(
931
+ (symbols, [name, symbol]) => (symbols.has(name) ? symbols : symbols.set(name, symbol)),
932
+ new Map(visible),
933
+ );
934
+ // Generator.generateModule reports the errors of a nested module and goes on, and then
935
+ // SymbolTable.addModule reports a module already defined.
694
936
  const linkNested = (nested: Module) => {
695
937
  const visibleModules = getVisibleModules();
696
- if (visibleModules.has(nested.name)) throw createModuleRedefinedError(nested);
938
+ const existing = visibleModules.get(nested.name);
939
+ const redefinition = existing && getModuleRedefinition(nested, existing.module);
940
+ if (existing && !redefinition) throw createModuleRedefinedError(nested);
697
941
  scope.nested.push(nested);
942
+ const report: ModuleReport = { location: nested.location, errors: [], warnings: [] };
943
+ reports.push(report);
698
944
  const linked = linkModule(nested, {
699
945
  id: `${scope.id}/${nested.name}`,
700
946
  symbols: getSymbolsBefore(nested.location),
701
947
  modules: visibleModules,
702
948
  nested: scope.nested,
949
+ errors: report.errors,
950
+ warnings: report.warnings,
951
+ levelChecks: scope.levelChecks,
703
952
  });
704
- modules.set(nested.name, linked);
953
+ if (redefinition) report.errors.push(redefinition);
954
+ if (!existing) modules.set(nested.name, linked);
705
955
  if (!nestedModules.has(nested.name)) nestedModules.set(nested.name, linked);
706
956
  };
707
957
  [
@@ -715,10 +965,13 @@ export const createEnvironment = (
715
965
  isParameterFree,
716
966
  getVisibleModules().get(instance.module),
717
967
  );
718
- symbols.forEach((_, name) => {
719
- if (!visible.has(name)) importedAt.set(name, instance.location);
968
+ instanced.set(instance, symbols);
969
+ symbols.forEach((symbol, name) => {
970
+ if (visible.has(name)) return;
971
+ importedAt.set(name, instance.location);
972
+ visible.set(name, symbol);
973
+ if (!instance.isLocal) exported.set(name, symbol);
720
974
  });
721
- addSymbols(symbols, !instance.isLocal);
722
975
  },
723
976
  })),
724
977
  ...parsed.modules.map((nested) => ({
@@ -728,37 +981,30 @@ export const createEnvironment = (
728
981
  ]
729
982
  .sort((left, right) => (isBefore(left.location, right.location) ? -1 : 1))
730
983
  .forEach((unit) => unit.link());
731
- checkRedefinitions(parsed, getUnit(parsed));
732
- const isInstancedAfterDefinition = (nested: Module) => {
733
- const first = parsed.instances.find((instance) => instance.module === nested.name);
734
- return first !== undefined && isBefore(nested.location, first.location);
735
- };
736
- const getLetModule = (instance: Instance) => {
737
- const own = parsed.modules.find((nested) => nested.name === instance.module);
738
- if (!own) return getVisibleModules().get(instance.module);
739
- return isInstancedAfterDefinition(own) ? modules.get(own.name) : undefined;
740
- };
741
984
  const module = resolveModuleSubexpressions(
742
985
  withLetInstances(parsed, (instance, lets) =>
743
986
  instantiateLocally(instance, lets, parsed.name, getLetModule(instance)),
744
987
  ),
745
988
  getAvailableDefinitions(visible),
746
989
  );
747
- resolveModule(module, getUnit(module));
990
+ scope.errors.push(...resolveModule(module, getUnit(module)));
748
991
  module.definitions.forEach((definition) => {
749
992
  const key = getKey(definition);
750
993
  definitions.set(key, definition);
751
994
  parameterized.set(key, !isParameterFree);
752
- const symbol = { key, arity: getArity(definition) };
995
+ const symbol = getDefinitionSymbol(definition);
996
+ const importedLocation = importedAt.get(definition.name);
997
+ // SANY binds the name of a fact to a fact the module imports before it.
998
+ if (
999
+ symbol.kind === "Theorem" &&
1000
+ visible.get(definition.name)?.kind === "Theorem" &&
1001
+ (importedLocation === undefined || isBefore(importedLocation, definition.location))
1002
+ ) {
1003
+ return;
1004
+ }
753
1005
  visible.set(definition.name, symbol);
754
1006
  if (!definition.isLocal) exported.set(definition.name, symbol);
755
1007
  });
756
- checkModuleLevels(module, {
757
- constants: new Set(constants.map((constant) => constant.name)),
758
- variables: new Set(variables),
759
- getDefinition: (symbol) => definitions.get(visible.get(symbol)?.key ?? symbol),
760
- getQualifiedName: (symbol) => qualifiedNames.get(visible.get(symbol)?.key ?? symbol),
761
- });
762
1008
  const linked = {
763
1009
  module,
764
1010
  constants,
@@ -768,12 +1014,36 @@ export const createEnvironment = (
768
1014
  exported,
769
1015
  modules,
770
1016
  extended,
1017
+ facts: new Set([
1018
+ ...facts,
1019
+ ...[...module.theorems, ...module.assumptions].flatMap((fact) => fact.name ?? []),
1020
+ ]),
771
1021
  };
1022
+ if (!checkedModules.has(parsed.name)) checkedModules.set(parsed.name, linked);
1023
+ // SANY checks the instances of a module with its definitions and theorems, so it reports their
1024
+ // errors together.
1025
+ const checks = instanceChecks
1026
+ .splice(firstCheck)
1027
+ .map((check) => ({ location: check.location, check: () => checkInstance(check) }));
1028
+ scope.levelChecks.push(() =>
1029
+ checkModuleLevels(
1030
+ module,
1031
+ {
1032
+ constants: new Set(constants.map((constant) => constant.name)),
1033
+ variables: new Set(variables),
1034
+ getDefinition: (symbol) => definitions.get(visible.get(symbol)?.key ?? symbol),
1035
+ getQualifiedName: (symbol) => qualifiedNames.get(visible.get(symbol)?.key ?? symbol),
1036
+ },
1037
+ checks,
1038
+ warnings,
1039
+ ),
1040
+ );
772
1041
  linkedList.push(linked);
773
1042
  return linked;
774
1043
  };
775
1044
 
776
1045
  const linkedRoot = linkTopLevel(root).linked;
1046
+ if (warnings.length > 0 && !options.isSanyReported) options.print(formatSanyWarnings(warnings));
777
1047
  const getRootKey = (name: string) => linkedRoot.visible.get(name)?.key ?? name;
778
1048
  linkedRoot.visible.forEach((symbol, name) => {
779
1049
  const definition = definitions.get(symbol.key);
@@ -815,6 +1085,7 @@ export const createEnvironment = (
815
1085
  .filter((assignment) => assignment.args === undefined)
816
1086
  .forEach((assignment) => {
817
1087
  const value = toValue(assignment.value);
1088
+ markNormalized(value);
818
1089
  getScopedKeys(assignment).forEach((key) => {
819
1090
  const arity = getKeyArity(key);
820
1091
  if (arity === 0) constants.set(key, value);
@@ -937,7 +1208,7 @@ export const createEnvironment = (
937
1208
  const unassigned = declaredConstants.filter(
938
1209
  (name) => !constants.has(name) && !substitutions.has(name) && !operatorKeys.has(name),
939
1210
  );
940
- if (unassigned.length > 0) {
1211
+ if (unassigned.length > 0 && !options.isUnconfigured) {
941
1212
  // TLC reports the first constant it finds unassigned in SANY's order of declarations.
942
1213
  const name =
943
1214
  getTlcDeclarationOrder(options.source, options.loadModule, "constant").find((constant) =>
@@ -948,12 +1219,20 @@ export const createEnvironment = (
948
1219
  );
949
1220
  }
950
1221
 
1222
+ if (options.isTraceRecorded) {
1223
+ builtins.forEach((builtin, name) => {
1224
+ const replacement = getTraceSpecArithmetic(builtin);
1225
+ if (replacement) builtins.set(name, replacement);
1226
+ });
1227
+ }
1228
+
951
1229
  const environment: Environment = {
952
1230
  runtime,
953
1231
  definitions,
954
1232
  builtins,
955
1233
  constants,
956
1234
  substitutions,
1235
+ instanceNames,
957
1236
  variables,
958
1237
  variableIndex: getVariableIndex(
959
1238
  variables,
@@ -961,23 +1240,9 @@ export const createEnvironment = (
961
1240
  ),
962
1241
  definitionValues: new Map(),
963
1242
  constantLevels: new Map(),
1243
+ substitutedDefinitions,
964
1244
  evaluators: new WeakMap(),
965
1245
  };
966
- checkInstances(instanceChecks, (name) => {
967
- const linked = linkedModules.get(name) ?? nestedModules.get(name) ?? linkedRoot;
968
- return {
969
- constants: linked.constants,
970
- variables: linked.variables,
971
- definitions: [
972
- ...new Set(
973
- [...linked.visible.values()].flatMap((symbol) => definitions.get(symbol.key) ?? []),
974
- ),
975
- ],
976
- assumptions: linked.module.assumptions.map((assumption) => assumption.expression),
977
- theorems: linked.module.theorems,
978
- getDefinition: (symbol) => definitions.get(linked.visible.get(symbol)?.key ?? symbol),
979
- };
980
- });
981
1246
  // TLC evaluates a substitute at startup and rejects it only when that fails and the level bound it
982
1247
  // computes is above constant. The bound counts the operators that TLC's Java code overrides with
983
1248
  // a minimum level as state-level, so the analyzer takes them for variables.
@@ -1007,18 +1272,41 @@ export const createEnvironment = (
1007
1272
  analyzer.analyzeDefinition(definition, new Map()).level > 0
1008
1273
  ? getEvaluationError(definition.body)
1009
1274
  : undefined;
1010
- // TLC adds the reason unless a standard module's Java code failed.
1011
1275
  if (error) {
1276
+ // TLC's SpecProcessor adds the message of a TLCRuntimeException, not of an EvalException.
1277
+ const addendum = isEvalException(error) ? "" : ` - specifically: ${error.message}`;
1012
1278
  throw new TlaConfigError(
1013
- `The configuration file substitutes constant ${name} with non-constant ${target}${error instanceof TlaModuleError ? "" : ` - specifically: ${error.message}`}`,
1279
+ `The configuration file substitutes constant ${name} with non-constant ${target}${addendum}`,
1014
1280
  );
1015
1281
  }
1016
1282
  });
1017
- runtime.isStarted = true;
1283
+ // TLC 1.7.4 processes the whole spec before it creates its model checker, which TLCGet reads.
1284
+ if (runtime.version !== "1.7.4") runtime.isStarted = true;
1285
+ // TLC computes the constant definitions of each module in the order SANY finishes the modules,
1286
+ // except those of a module that an INSTANCE gives parameters to.
1287
+ const instantiated = new Set(
1288
+ linkedList.flatMap((linked) => linked.module.instances.map((instance) => instance.module)),
1289
+ );
1290
+ const getDefinitionOrder = createTlcDefinitionOrder(options.source, options.loadModule);
1018
1291
  return {
1019
1292
  environment,
1020
1293
  assumptions,
1021
1294
  variableLocations: linkedRoot.variableLocations,
1022
1295
  instanceActions,
1296
+ startupDefinitions: linkedList
1297
+ .filter(
1298
+ (linked) => !instantiated.has(linked.module.name) || getDeclarations(linked).length === 0,
1299
+ )
1300
+ .flatMap((linked) =>
1301
+ getDefinitionOrder(linked === linkedRoot ? undefined : linked.module.name).flatMap(
1302
+ (name) => {
1303
+ const definition = definitions.get(linked.visible.get(name)?.key ?? name);
1304
+ return definition ? [definition] : [];
1305
+ },
1306
+ ),
1307
+ ),
1308
+ rootConstants: linkedRoot.constants,
1309
+ rootSymbols: linkedRoot.visible,
1310
+ javaOverrides: linkedList.flatMap((linked) => javaOverrides.get(linked.module.name) ?? []),
1023
1311
  };
1024
1312
  };