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.
- package/dist/cli.cjs +1 -1
- package/dist/cli.js +1 -1
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +160 -46
- package/dist/index.d.ts +160 -46
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +2 -2
- package/dist/parallel.cjs +1 -1
- package/dist/parallel.js +2 -2
- package/dist/run-cli.cjs +1351 -22
- package/dist/run-cli.js +1351 -22
- package/dist/transfer.cjs +83 -33
- package/dist/transfer.js +83 -33
- package/package.json +4 -1
- package/src/ast.ts +42 -5
- package/src/bags.ts +4 -7
- package/src/builtins.ts +29 -17
- package/src/bundled-modules.ts +3 -3
- package/src/canonical.ts +4 -3
- package/src/check.ts +1296 -429
- package/src/cli.ts +8 -1
- package/src/codegen.ts +68 -21
- package/src/config.ts +225 -206
- package/src/environment.ts +388 -115
- package/src/errors.ts +155 -18
- package/src/evaluate.ts +713 -259
- package/src/exit-codes.ts +6 -24
- package/src/fingerprints.ts +1 -2
- package/src/index.ts +1 -0
- package/src/instances.ts +3 -1
- package/src/java-overrides.ts +104 -25
- package/src/levels.ts +37 -27
- package/src/lexer.ts +14 -1
- package/src/live-check.ts +204 -148
- package/src/liveness.ts +191 -122
- package/src/obligation-expression.ts +2 -2
- package/src/obligation-source.ts +2 -0
- package/src/parallel-worker.ts +6 -1
- package/src/parallel.ts +57 -6
- package/src/parser.ts +369 -115
- package/src/pcal-ast.ts +770 -0
- package/src/pcal-parse.ts +1523 -0
- package/src/pcal-tokenize.ts +516 -0
- package/src/pcal-translate.ts +1230 -0
- package/src/pcal-validate.ts +454 -0
- package/src/randomization.ts +24 -7
- package/src/resolve.ts +1332 -453
- package/src/run-cli.ts +1161 -196
- package/src/runtime.ts +16 -0
- package/src/sany-builtins.ts +147 -0
- package/src/sany-generator.ts +3112 -0
- package/src/sany-levels.ts +1208 -0
- package/src/sany-lexer.ts +545 -0
- package/src/sany-linter.ts +122 -0
- package/src/sany-modules.ts +1398 -0
- package/src/sany-nodes.ts +463 -0
- package/src/sany-parse-error.ts +2161 -0
- package/src/sany-report.ts +354 -0
- package/src/sany-selectors.ts +738 -0
- package/src/sany-source.ts +248 -0
- package/src/sany-xml.ts +1017 -0
- package/src/spec-description.ts +25 -5
- package/src/standard-modules.ts +172 -129
- package/src/standard-ranges.ts +116 -0
- package/src/state-graph.ts +29 -6
- package/src/subexpressions.ts +221 -161
- package/src/successors.ts +141 -173
- package/src/symmetry.ts +168 -50
- package/src/tableau.ts +3 -1
- package/src/tlc-ext.ts +13 -17
- package/src/tlc-messages.ts +329 -0
- package/src/tlc-module.ts +49 -21
- package/src/tlc-modules.ts +0 -4
- package/src/tlc-order.ts +55 -9
- package/src/tlc-random.ts +28 -3
- package/src/tlc-replay.ts +655 -0
- package/src/tlc-version.ts +18 -0
- package/src/transfer.ts +15 -3
- package/src/values.ts +664 -317
package/src/environment.ts
CHANGED
|
@@ -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 {
|
|
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 {
|
|
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) => ({
|
|
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, {
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
436
|
-
|
|
437
|
-
|
|
438
|
-
|
|
439
|
-
|
|
440
|
-
|
|
441
|
-
|
|
442
|
-
|
|
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
|
-
|
|
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
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
673
|
-
|
|
674
|
-
|
|
675
|
-
|
|
676
|
-
|
|
677
|
-
|
|
678
|
-
|
|
679
|
-
|
|
680
|
-
|
|
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
|
|
686
|
-
const
|
|
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
|
-
|
|
689
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
737
|
-
|
|
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 =
|
|
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
|
-
|
|
788
|
-
|
|
789
|
-
{
|
|
790
|
-
|
|
791
|
-
|
|
792
|
-
|
|
793
|
-
|
|
794
|
-
|
|
795
|
-
|
|
796
|
-
|
|
797
|
-
|
|
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}${
|
|
1276
|
+
`The configuration file substitutes constant ${name} with non-constant ${target}${addendum}`,
|
|
1026
1277
|
);
|
|
1027
1278
|
}
|
|
1028
1279
|
});
|
|
1029
|
-
|
|
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
|
};
|