tla-ts 0.0.3-dev.fca2ca8 → 0.0.3-dev.fe239f8
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 +168 -27
- package/dist/index.d.ts +168 -27
- 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 -20
- package/dist/run-cli.js +1351 -20
- package/dist/transfer.cjs +83 -28
- package/dist/transfer.js +83 -28
- package/package.json +5 -1
- package/src/ast.ts +55 -6
- package/src/bags.ts +4 -7
- package/src/builtins.ts +29 -11
- package/src/bundled-modules.ts +3 -3
- package/src/canonical.ts +4 -3
- package/src/check.ts +1343 -284
- package/src/cli.ts +8 -1
- package/src/codegen.ts +68 -21
- package/src/config.ts +252 -179
- package/src/environment.ts +431 -120
- package/src/errors.ts +195 -7
- package/src/evaluate.ts +718 -146
- package/src/exit-codes.ts +6 -24
- package/src/index.ts +1 -0
- package/src/instances.ts +4 -2
- package/src/java-overrides.ts +104 -25
- package/src/levels.ts +183 -37
- package/src/lexer.ts +32 -4
- package/src/live-check.ts +204 -148
- package/src/liveness.ts +190 -117
- 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 +450 -135
- 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 +1367 -404
- package/src/run-cli.ts +1167 -155
- 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 +26 -7
- package/src/standard-modules.ts +203 -146
- package/src/standard-ranges.ts +116 -0
- package/src/state-graph.ts +29 -6
- package/src/subexpressions.ts +221 -161
- package/src/substitution-levels.ts +38 -17
- package/src/successors.ts +158 -120
- 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/value-sources.ts +29 -0
- package/src/values.ts +683 -256
package/src/environment.ts
CHANGED
|
@@ -12,7 +12,16 @@ import {
|
|
|
12
12
|
import { BUNDLED_MODULES } from "./bundled-modules";
|
|
13
13
|
import type { ConfigValue, ModelConfig } from "./config";
|
|
14
14
|
import type { FileSystem } from "./json";
|
|
15
|
-
import {
|
|
15
|
+
import {
|
|
16
|
+
createSanyError,
|
|
17
|
+
createMissingModuleError,
|
|
18
|
+
formatRange,
|
|
19
|
+
formatSanyWarnings,
|
|
20
|
+
TlaConfigError,
|
|
21
|
+
TlaEvaluationError,
|
|
22
|
+
TlaSyntaxError,
|
|
23
|
+
type SanyError,
|
|
24
|
+
} from "./errors";
|
|
16
25
|
import { EXIT_STATUS, setExitCode } from "./exit-codes";
|
|
17
26
|
import {
|
|
18
27
|
createBigNumberError,
|
|
@@ -29,25 +38,39 @@ import {
|
|
|
29
38
|
renameLocals,
|
|
30
39
|
withLetInstances,
|
|
31
40
|
} from "./instances";
|
|
32
|
-
import { overrideDefinitions } from "./java-overrides";
|
|
41
|
+
import { overrideDefinitions, type JavaOverride } from "./java-overrides";
|
|
33
42
|
import { extractModule, parseModule } from "./parser";
|
|
34
43
|
import {
|
|
35
|
-
checkRedefinitions,
|
|
36
44
|
getArity,
|
|
45
|
+
getParamArities,
|
|
37
46
|
isBefore,
|
|
47
|
+
isTheoremDefinition,
|
|
38
48
|
KEY_SEPARATOR,
|
|
39
49
|
LOCAL_RESOLUTION,
|
|
50
|
+
MODULE_START,
|
|
40
51
|
resolveModule,
|
|
41
52
|
resolveSubstitutions,
|
|
53
|
+
type ModuleReport,
|
|
42
54
|
type ModuleSymbol,
|
|
55
|
+
type ModuleUnit,
|
|
56
|
+
type SymbolKind,
|
|
43
57
|
type Symbols,
|
|
44
58
|
} from "./resolve";
|
|
45
59
|
import { createRuntime } from "./runtime";
|
|
46
|
-
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";
|
|
47
69
|
import { resolveInstanceSubexpressions, resolveModuleSubexpressions } from "./subexpressions";
|
|
48
70
|
import { checkModuleLevels, createLevelAnalyzer } from "./levels";
|
|
49
|
-
import {
|
|
50
|
-
import {
|
|
71
|
+
import { createInstanceChecker, type InstanceCheck } from "./substitution-levels";
|
|
72
|
+
import { isEvalException } from "./tlc-messages";
|
|
73
|
+
import { createTlcDefinitionOrder, getTlcDeclarationOrder } from "./tlc-order";
|
|
51
74
|
import {
|
|
52
75
|
checkInteger,
|
|
53
76
|
createModelValue,
|
|
@@ -55,7 +78,9 @@ import {
|
|
|
55
78
|
formatValue,
|
|
56
79
|
valuesEqual,
|
|
57
80
|
type Value,
|
|
81
|
+
markNormalized,
|
|
58
82
|
} from "./values";
|
|
83
|
+
import type { TlcVersion } from "./tlc-version";
|
|
59
84
|
|
|
60
85
|
interface EnvironmentOptions {
|
|
61
86
|
source: string;
|
|
@@ -64,6 +89,15 @@ interface EnvironmentOptions {
|
|
|
64
89
|
print: (text: string) => void;
|
|
65
90
|
files: FileSystem;
|
|
66
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;
|
|
67
101
|
}
|
|
68
102
|
|
|
69
103
|
interface Specification {
|
|
@@ -71,6 +105,12 @@ interface Specification {
|
|
|
71
105
|
assumptions: Assumption[];
|
|
72
106
|
variableLocations: SourceLocation[];
|
|
73
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[];
|
|
74
114
|
}
|
|
75
115
|
|
|
76
116
|
export interface InstanceAction {
|
|
@@ -106,25 +146,73 @@ interface LinkedModule {
|
|
|
106
146
|
exported: Symbols;
|
|
107
147
|
modules: Map<string, LinkedModule>;
|
|
108
148
|
extended: LinkedModule[];
|
|
149
|
+
facts: Set<string>;
|
|
109
150
|
}
|
|
110
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.
|
|
111
154
|
interface ModuleScope {
|
|
112
155
|
id: string;
|
|
113
156
|
symbols: Symbols;
|
|
114
157
|
modules: Map<string, LinkedModule>;
|
|
115
158
|
nested: Module[];
|
|
159
|
+
errors: SanyError[];
|
|
160
|
+
warnings: SanyError[];
|
|
161
|
+
levelChecks: (() => void)[];
|
|
116
162
|
}
|
|
117
163
|
|
|
118
|
-
const getDeclarations = (linked: LinkedModule) => [
|
|
164
|
+
const getDeclarations = (linked: LinkedModule): Declaration[] => [
|
|
119
165
|
...linked.constants,
|
|
120
|
-
...linked.variables.map((variable) => ({
|
|
166
|
+
...linked.variables.map((variable, index) => ({
|
|
167
|
+
name: variable,
|
|
168
|
+
arity: 0,
|
|
169
|
+
location: linked.variableLocations[index],
|
|
170
|
+
})),
|
|
121
171
|
];
|
|
122
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
|
+
|
|
123
195
|
const createModuleRedefinedError = (module: Module) =>
|
|
124
196
|
new TlaSyntaxError(
|
|
125
197
|
`Multiply-defined module '${module.name}' at line ${module.location.line}, column ${module.location.column}`,
|
|
126
198
|
);
|
|
127
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
|
+
|
|
128
216
|
const createLocalFunction = (definition: Definition, key: string): Definition => ({
|
|
129
217
|
kind: "Operator",
|
|
130
218
|
name: key,
|
|
@@ -216,13 +304,19 @@ export const createEnvironment = (
|
|
|
216
304
|
const parameterized = new Map<string, boolean>();
|
|
217
305
|
// The definition each instance copy came from, and the instance parameters the copy adds.
|
|
218
306
|
const copySources = new Map<string, { source: string; prefix: number }>();
|
|
307
|
+
const substitutedDefinitions = new Set<Definition>();
|
|
219
308
|
const builtins = new Map<string, Builtin>(
|
|
220
309
|
CORE_OPERATORS.map((operator) => [operator.name, operator]),
|
|
221
310
|
);
|
|
222
311
|
const standardExports = new Map<string, Symbols>();
|
|
223
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";
|
|
224
316
|
const linkedModules = new Map<string, LinkedModule>();
|
|
225
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>();
|
|
226
320
|
const linkedList: LinkedModule[] = [];
|
|
227
321
|
const dependencies = new Map<string, Set<string>>();
|
|
228
322
|
const loading: Set<string>[] = [];
|
|
@@ -237,13 +331,35 @@ export const createEnvironment = (
|
|
|
237
331
|
const copyCount = { value: 0 };
|
|
238
332
|
const createName = (name: string) => `${name}#${copyCount.value++}`;
|
|
239
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
|
+
});
|
|
240
351
|
const instanceActions = new Map<string, InstanceAction>();
|
|
352
|
+
const instanceNames = new Map<string, string>();
|
|
353
|
+
const qualifiedNames = new Map<string, string>();
|
|
241
354
|
|
|
242
355
|
const addStandardModule = (name: string): Symbols | undefined => {
|
|
243
356
|
const cached = standardExports.get(name);
|
|
244
357
|
if (cached) return cached;
|
|
245
|
-
const standardModule = getStandardModule(name, options.print, runtime, options.files);
|
|
358
|
+
const standardModule = getStandardModule(name, options.print, runtime, options.files, builtins);
|
|
246
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);
|
|
247
363
|
const exported: Symbols = new Map();
|
|
248
364
|
standardModule.extends.forEach((extended) =>
|
|
249
365
|
addStandardModule(extended)?.forEach((symbol, symbolName) =>
|
|
@@ -252,7 +368,13 @@ export const createEnvironment = (
|
|
|
252
368
|
);
|
|
253
369
|
standardModule.operators.forEach((operator) => {
|
|
254
370
|
builtins.set(operator.name, operator);
|
|
255
|
-
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
|
+
});
|
|
256
378
|
});
|
|
257
379
|
standardExports.set(name, exported);
|
|
258
380
|
return exported;
|
|
@@ -260,7 +382,11 @@ export const createEnvironment = (
|
|
|
260
382
|
|
|
261
383
|
const getStandardSymbols = (name: string) => {
|
|
262
384
|
const symbols = addStandardModule(name);
|
|
263
|
-
|
|
385
|
+
const dependencies = STANDARD_DEPENDENCIES.get(name) ?? [];
|
|
386
|
+
if (symbols) useModule(name, dependencies);
|
|
387
|
+
// TLC loads the Java class of each module a standard module uses, so one that uses Integers
|
|
388
|
+
// overrides the arithmetic of Naturals.
|
|
389
|
+
if (symbols && dependencies.includes("Integers")) addStandardModule("Integers");
|
|
264
390
|
return symbols;
|
|
265
391
|
};
|
|
266
392
|
|
|
@@ -288,14 +414,17 @@ export const createEnvironment = (
|
|
|
288
414
|
options.loadModule?.(name) ??
|
|
289
415
|
BUNDLED_MODULES.get(name) ??
|
|
290
416
|
extractModule(options.source, name);
|
|
291
|
-
if (source === undefined)
|
|
292
|
-
|
|
293
|
-
`Cannot find source file for module ${name} imported in module ${importer}.`,
|
|
294
|
-
);
|
|
295
|
-
const module = parseModule(source);
|
|
417
|
+
if (source === undefined) throw createMissingModuleError(name, importer);
|
|
418
|
+
const module = parseModuleFile(source, name);
|
|
296
419
|
if (module.name !== name) {
|
|
297
|
-
throw
|
|
298
|
-
|
|
420
|
+
throw createSanyError(
|
|
421
|
+
[
|
|
422
|
+
{
|
|
423
|
+
location: "Unknown location",
|
|
424
|
+
message: `File name '${name}' does not match the name '${module.name}' of the top level module it contains.`,
|
|
425
|
+
},
|
|
426
|
+
],
|
|
427
|
+
true,
|
|
299
428
|
);
|
|
300
429
|
}
|
|
301
430
|
return rejectModuleLiterals(module);
|
|
@@ -311,6 +440,8 @@ export const createEnvironment = (
|
|
|
311
440
|
}
|
|
312
441
|
const closure = new Set<string>();
|
|
313
442
|
const nested: Module[] = [];
|
|
443
|
+
const errors: SanyError[] = [];
|
|
444
|
+
const levelChecks: (() => void)[] = [];
|
|
314
445
|
linking.push(parsed.name);
|
|
315
446
|
loading.push(closure);
|
|
316
447
|
const linked = linkModule(parsed, {
|
|
@@ -318,11 +449,19 @@ export const createEnvironment = (
|
|
|
318
449
|
symbols: new Map(),
|
|
319
450
|
modules: new Map(),
|
|
320
451
|
nested,
|
|
452
|
+
errors,
|
|
453
|
+
warnings,
|
|
454
|
+
levelChecks,
|
|
321
455
|
});
|
|
322
456
|
loading.pop();
|
|
323
457
|
linking.pop();
|
|
458
|
+
if (errors.length > 0) throw createSanyError(errors, false, undefined, warnings);
|
|
324
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);
|
|
325
463
|
if (duplicate) throw createModuleRedefinedError(duplicate);
|
|
464
|
+
levelChecks.forEach((check) => check());
|
|
326
465
|
return { linked, closure };
|
|
327
466
|
};
|
|
328
467
|
|
|
@@ -342,23 +481,16 @@ export const createEnvironment = (
|
|
|
342
481
|
const instantiate = (
|
|
343
482
|
instance: Instance,
|
|
344
483
|
module: Module,
|
|
345
|
-
unit:
|
|
346
|
-
imported: Symbols;
|
|
347
|
-
importedAt: Map<string, SourceLocation>;
|
|
348
|
-
definitions: Map<string, Definition>;
|
|
349
|
-
getKey: (definition: Definition) => string;
|
|
350
|
-
},
|
|
484
|
+
unit: ModuleUnit,
|
|
351
485
|
isParameterFree: boolean,
|
|
352
486
|
nested: LinkedModule | undefined,
|
|
353
487
|
): Symbols => {
|
|
354
488
|
const standardSymbols = nested ? undefined : getStandardSymbols(instance.module);
|
|
355
|
-
if (standardSymbols)
|
|
356
|
-
if (instance.name === undefined) return standardSymbols;
|
|
357
|
-
return new Map(
|
|
358
|
-
[...standardSymbols].map(([name, symbol]) => [`${instance.name}!${name}`, symbol]),
|
|
359
|
-
);
|
|
360
|
-
}
|
|
489
|
+
if (standardSymbols) return getStandardInstanceSymbols(instance, standardSymbols);
|
|
361
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
|
+
);
|
|
362
494
|
const declarations = getDeclarations(linked);
|
|
363
495
|
const suffix = `#${copyCount.value++}`;
|
|
364
496
|
const renamed = new Map(instance.params.map((param) => [param.name, `${param.name}${suffix}`]));
|
|
@@ -385,34 +517,81 @@ export const createEnvironment = (
|
|
|
385
517
|
isParameterized: (key) => parameterized.get(key) === true,
|
|
386
518
|
addDefinition: (source, name, create) => {
|
|
387
519
|
const key = createName(`${name}@${module.name}`);
|
|
388
|
-
|
|
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
|
+
}
|
|
389
526
|
parameterized.set(key, !isParameterFree);
|
|
390
527
|
copySources.set(key, { source, prefix: instance.params.length });
|
|
391
528
|
return key;
|
|
392
529
|
},
|
|
393
530
|
createName,
|
|
394
531
|
});
|
|
395
|
-
|
|
396
|
-
|
|
397
|
-
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
|
|
403
|
-
symbols.set(name, { key, arity: symbol.arity });
|
|
404
|
-
return;
|
|
405
|
-
}
|
|
406
|
-
const key = instantiation.getQualifiedKey(symbol.key);
|
|
407
|
-
if (declarations.length > 0) {
|
|
408
|
-
instanceActions.set(key, { name: `${instance.name}!${name}`, location: instance.location });
|
|
409
|
-
}
|
|
410
|
-
symbols.set(`${instance.name}!${name}`, {
|
|
411
|
-
key,
|
|
412
|
-
arity: symbol.arity + instance.params.length,
|
|
413
|
-
});
|
|
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;
|
|
414
540
|
});
|
|
415
|
-
|
|
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
|
+
);
|
|
416
595
|
};
|
|
417
596
|
|
|
418
597
|
const getLocalArguments = (params: OperatorParam[], location: SourceLocation) =>
|
|
@@ -585,31 +764,70 @@ export const createEnvironment = (
|
|
|
585
764
|
return definition ? [{ ...definition, name }] : [];
|
|
586
765
|
});
|
|
587
766
|
|
|
767
|
+
const javaOverrides = new Map<string, JavaOverride[]>();
|
|
588
768
|
const linkModule = (unlinked: Module, scope: ModuleScope): LinkedModule => {
|
|
589
|
-
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;
|
|
776
|
+
const firstCheck = instanceChecks.length;
|
|
590
777
|
const visible: Symbols = new Map([
|
|
591
778
|
...CORE_OPERATORS.map((operator): [string, ModuleSymbol] => [
|
|
592
779
|
operator.name,
|
|
593
|
-
{ key: operator.name, arity: operator.arity },
|
|
780
|
+
{ key: operator.name, arity: operator.arity, kind: "Builtin" },
|
|
594
781
|
]),
|
|
595
782
|
...scope.symbols,
|
|
596
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
|
+
});
|
|
597
819
|
const exported: Symbols = new Map();
|
|
820
|
+
const facts = new Set<string>();
|
|
598
821
|
const modules = new Map<string, LinkedModule>();
|
|
599
822
|
const extended: LinkedModule[] = [];
|
|
600
823
|
const constants = [...parsed.constants];
|
|
601
824
|
const variables = parsed.variables.map((variable) => variable.name);
|
|
602
825
|
const variableLocations = parsed.variables.map((variable) => variable.location);
|
|
603
|
-
const addSymbols = (symbols: Symbols, isExported: boolean) =>
|
|
604
|
-
symbols.forEach((symbol, name) => {
|
|
605
|
-
visible.set(name, symbol);
|
|
606
|
-
if (isExported) exported.set(name, symbol);
|
|
607
|
-
});
|
|
608
826
|
parsed.extends.forEach((name) => {
|
|
609
827
|
const nested = scope.modules.get(name);
|
|
610
828
|
const standardSymbols = nested ? undefined : getStandardSymbols(name);
|
|
611
829
|
if (standardSymbols) {
|
|
612
|
-
|
|
830
|
+
mergeExtended(standardSymbols);
|
|
613
831
|
return;
|
|
614
832
|
}
|
|
615
833
|
const linked = nested ?? getLinkedModule(name, parsed.name);
|
|
@@ -623,61 +841,114 @@ export const createEnvironment = (
|
|
|
623
841
|
variables.push(variable);
|
|
624
842
|
variableLocations.push(linked.variableLocations[index]);
|
|
625
843
|
});
|
|
626
|
-
|
|
844
|
+
mergeExtended(linked.exported);
|
|
845
|
+
linked.facts.forEach((name) => facts.add(name));
|
|
627
846
|
linked.modules.forEach((module, moduleName) => modules.set(moduleName, module));
|
|
628
847
|
extended.push(linked);
|
|
629
848
|
});
|
|
630
|
-
|
|
631
|
-
|
|
632
|
-
|
|
633
|
-
|
|
634
|
-
|
|
635
|
-
|
|
636
|
-
|
|
637
|
-
|
|
638
|
-
|
|
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)),
|
|
639
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
|
+
});
|
|
640
870
|
const isParameterFree = constants.length === 0 && variables.length === 0;
|
|
641
871
|
const getKey = (definition: Definition) =>
|
|
642
872
|
parsed === root ? definition.name : `${definition.name}${KEY_SEPARATOR}${scope.id}`;
|
|
643
|
-
const
|
|
644
|
-
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 => ({
|
|
645
885
|
imported: visible,
|
|
646
|
-
|
|
647
|
-
|
|
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
|
+
),
|
|
648
909
|
getKey,
|
|
910
|
+
instanced,
|
|
911
|
+
facts,
|
|
912
|
+
reports,
|
|
913
|
+
warnings: scope.warnings,
|
|
649
914
|
});
|
|
650
|
-
const getVisibleModules = () => new Map([...scope.modules, ...modules]);
|
|
651
915
|
const getSymbolsBefore = (location: SourceLocation): Symbols =>
|
|
652
916
|
new Map([
|
|
653
917
|
...visible,
|
|
654
|
-
...
|
|
655
|
-
...parsed.constants.map((constant) => ({ ...constant, kind: "Constant" as const })),
|
|
656
|
-
...parsed.variables.map((variable) => ({ ...variable, kind: "Variable" as const })),
|
|
657
|
-
]
|
|
918
|
+
...declarations
|
|
658
919
|
.filter((declaration) => isBefore(declaration.location, location))
|
|
659
920
|
.map((declaration): [string, ModuleSymbol] => [
|
|
660
921
|
declaration.name,
|
|
661
|
-
|
|
922
|
+
getDeclarationSymbol(declaration),
|
|
662
923
|
]),
|
|
663
924
|
...parsed.definitions
|
|
664
925
|
.filter((definition) => isBefore(definition.location, location))
|
|
665
926
|
.map((definition): [string, ModuleSymbol] => [
|
|
666
927
|
definition.name,
|
|
667
|
-
|
|
928
|
+
getDefinitionSymbol(definition),
|
|
668
929
|
]),
|
|
669
930
|
]);
|
|
931
|
+
// Generator.generateModule reports the errors of a nested module and goes on, and then
|
|
932
|
+
// SymbolTable.addModule reports a module already defined.
|
|
670
933
|
const linkNested = (nested: Module) => {
|
|
671
934
|
const visibleModules = getVisibleModules();
|
|
672
|
-
|
|
935
|
+
const existing = visibleModules.get(nested.name);
|
|
936
|
+
const redefinition = existing && getModuleRedefinition(nested, existing.module);
|
|
937
|
+
if (existing && !redefinition) throw createModuleRedefinedError(nested);
|
|
673
938
|
scope.nested.push(nested);
|
|
939
|
+
const report: ModuleReport = { location: nested.location, errors: [], warnings: [] };
|
|
940
|
+
reports.push(report);
|
|
674
941
|
const linked = linkModule(nested, {
|
|
675
942
|
id: `${scope.id}/${nested.name}`,
|
|
676
943
|
symbols: getSymbolsBefore(nested.location),
|
|
677
944
|
modules: visibleModules,
|
|
678
945
|
nested: scope.nested,
|
|
946
|
+
errors: report.errors,
|
|
947
|
+
warnings: report.warnings,
|
|
948
|
+
levelChecks: scope.levelChecks,
|
|
679
949
|
});
|
|
680
|
-
|
|
950
|
+
if (redefinition) report.errors.push(redefinition);
|
|
951
|
+
if (!existing) modules.set(nested.name, linked);
|
|
681
952
|
if (!nestedModules.has(nested.name)) nestedModules.set(nested.name, linked);
|
|
682
953
|
};
|
|
683
954
|
[
|
|
@@ -691,10 +962,13 @@ export const createEnvironment = (
|
|
|
691
962
|
isParameterFree,
|
|
692
963
|
getVisibleModules().get(instance.module),
|
|
693
964
|
);
|
|
694
|
-
|
|
695
|
-
|
|
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);
|
|
696
971
|
});
|
|
697
|
-
addSymbols(symbols, !instance.isLocal);
|
|
698
972
|
},
|
|
699
973
|
})),
|
|
700
974
|
...parsed.modules.map((nested) => ({
|
|
@@ -704,36 +978,30 @@ export const createEnvironment = (
|
|
|
704
978
|
]
|
|
705
979
|
.sort((left, right) => (isBefore(left.location, right.location) ? -1 : 1))
|
|
706
980
|
.forEach((unit) => unit.link());
|
|
707
|
-
checkRedefinitions(parsed, getUnit(parsed));
|
|
708
|
-
const isInstancedAfterDefinition = (nested: Module) => {
|
|
709
|
-
const first = parsed.instances.find((instance) => instance.module === nested.name);
|
|
710
|
-
return first !== undefined && isBefore(nested.location, first.location);
|
|
711
|
-
};
|
|
712
|
-
const getLetModule = (instance: Instance) => {
|
|
713
|
-
const own = parsed.modules.find((nested) => nested.name === instance.module);
|
|
714
|
-
if (!own) return getVisibleModules().get(instance.module);
|
|
715
|
-
return isInstancedAfterDefinition(own) ? modules.get(own.name) : undefined;
|
|
716
|
-
};
|
|
717
981
|
const module = resolveModuleSubexpressions(
|
|
718
982
|
withLetInstances(parsed, (instance, lets) =>
|
|
719
983
|
instantiateLocally(instance, lets, parsed.name, getLetModule(instance)),
|
|
720
984
|
),
|
|
721
985
|
getAvailableDefinitions(visible),
|
|
722
986
|
);
|
|
723
|
-
resolveModule(module, getUnit(module));
|
|
987
|
+
scope.errors.push(...resolveModule(module, getUnit(module)));
|
|
724
988
|
module.definitions.forEach((definition) => {
|
|
725
989
|
const key = getKey(definition);
|
|
726
990
|
definitions.set(key, definition);
|
|
727
991
|
parameterized.set(key, !isParameterFree);
|
|
728
|
-
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
|
+
}
|
|
729
1002
|
visible.set(definition.name, symbol);
|
|
730
1003
|
if (!definition.isLocal) exported.set(definition.name, symbol);
|
|
731
1004
|
});
|
|
732
|
-
checkModuleLevels(module, {
|
|
733
|
-
constants: new Set(constants.map((constant) => constant.name)),
|
|
734
|
-
variables: new Set(variables),
|
|
735
|
-
getDefinition: (symbol) => definitions.get(visible.get(symbol)?.key ?? symbol),
|
|
736
|
-
});
|
|
737
1005
|
const linked = {
|
|
738
1006
|
module,
|
|
739
1007
|
constants,
|
|
@@ -743,12 +1011,36 @@ export const createEnvironment = (
|
|
|
743
1011
|
exported,
|
|
744
1012
|
modules,
|
|
745
1013
|
extended,
|
|
1014
|
+
facts: new Set([
|
|
1015
|
+
...facts,
|
|
1016
|
+
...[...module.theorems, ...module.assumptions].flatMap((fact) => fact.name ?? []),
|
|
1017
|
+
]),
|
|
746
1018
|
};
|
|
1019
|
+
if (!checkedModules.has(parsed.name)) checkedModules.set(parsed.name, linked);
|
|
1020
|
+
// SANY checks the instances of a module with its definitions and theorems, so it reports their
|
|
1021
|
+
// errors together.
|
|
1022
|
+
const checks = instanceChecks
|
|
1023
|
+
.splice(firstCheck)
|
|
1024
|
+
.map((check) => ({ location: check.location, check: () => checkInstance(check) }));
|
|
1025
|
+
scope.levelChecks.push(() =>
|
|
1026
|
+
checkModuleLevels(
|
|
1027
|
+
module,
|
|
1028
|
+
{
|
|
1029
|
+
constants: new Set(constants.map((constant) => constant.name)),
|
|
1030
|
+
variables: new Set(variables),
|
|
1031
|
+
getDefinition: (symbol) => definitions.get(visible.get(symbol)?.key ?? symbol),
|
|
1032
|
+
getQualifiedName: (symbol) => qualifiedNames.get(visible.get(symbol)?.key ?? symbol),
|
|
1033
|
+
},
|
|
1034
|
+
checks,
|
|
1035
|
+
warnings,
|
|
1036
|
+
),
|
|
1037
|
+
);
|
|
747
1038
|
linkedList.push(linked);
|
|
748
1039
|
return linked;
|
|
749
1040
|
};
|
|
750
1041
|
|
|
751
1042
|
const linkedRoot = linkTopLevel(root).linked;
|
|
1043
|
+
if (warnings.length > 0 && !options.isSanyReported) options.print(formatSanyWarnings(warnings));
|
|
752
1044
|
const getRootKey = (name: string) => linkedRoot.visible.get(name)?.key ?? name;
|
|
753
1045
|
linkedRoot.visible.forEach((symbol, name) => {
|
|
754
1046
|
const definition = definitions.get(symbol.key);
|
|
@@ -790,6 +1082,7 @@ export const createEnvironment = (
|
|
|
790
1082
|
.filter((assignment) => assignment.args === undefined)
|
|
791
1083
|
.forEach((assignment) => {
|
|
792
1084
|
const value = toValue(assignment.value);
|
|
1085
|
+
markNormalized(value);
|
|
793
1086
|
getScopedKeys(assignment).forEach((key) => {
|
|
794
1087
|
const arity = getKeyArity(key);
|
|
795
1088
|
if (arity === 0) constants.set(key, value);
|
|
@@ -912,7 +1205,7 @@ export const createEnvironment = (
|
|
|
912
1205
|
const unassigned = declaredConstants.filter(
|
|
913
1206
|
(name) => !constants.has(name) && !substitutions.has(name) && !operatorKeys.has(name),
|
|
914
1207
|
);
|
|
915
|
-
if (unassigned.length > 0) {
|
|
1208
|
+
if (unassigned.length > 0 && !options.isUnconfigured) {
|
|
916
1209
|
// TLC reports the first constant it finds unassigned in SANY's order of declarations.
|
|
917
1210
|
const name =
|
|
918
1211
|
getTlcDeclarationOrder(options.source, options.loadModule, "constant").find((constant) =>
|
|
@@ -923,12 +1216,20 @@ export const createEnvironment = (
|
|
|
923
1216
|
);
|
|
924
1217
|
}
|
|
925
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
|
+
|
|
926
1226
|
const environment: Environment = {
|
|
927
1227
|
runtime,
|
|
928
1228
|
definitions,
|
|
929
1229
|
builtins,
|
|
930
1230
|
constants,
|
|
931
1231
|
substitutions,
|
|
1232
|
+
instanceNames,
|
|
932
1233
|
variables,
|
|
933
1234
|
variableIndex: getVariableIndex(
|
|
934
1235
|
variables,
|
|
@@ -936,22 +1237,9 @@ export const createEnvironment = (
|
|
|
936
1237
|
),
|
|
937
1238
|
definitionValues: new Map(),
|
|
938
1239
|
constantLevels: new Map(),
|
|
1240
|
+
substitutedDefinitions,
|
|
939
1241
|
evaluators: new WeakMap(),
|
|
940
1242
|
};
|
|
941
|
-
checkInstances(instanceChecks, (name) => {
|
|
942
|
-
const linked = linkedModules.get(name) ?? nestedModules.get(name) ?? linkedRoot;
|
|
943
|
-
return {
|
|
944
|
-
constants: linked.constants,
|
|
945
|
-
variables: linked.variables,
|
|
946
|
-
definitions: [
|
|
947
|
-
...new Set(
|
|
948
|
-
[...linked.visible.values()].flatMap((symbol) => definitions.get(symbol.key) ?? []),
|
|
949
|
-
),
|
|
950
|
-
],
|
|
951
|
-
assumptions: linked.module.assumptions.map((assumption) => assumption.expression),
|
|
952
|
-
getDefinition: (symbol) => definitions.get(linked.visible.get(symbol)?.key ?? symbol),
|
|
953
|
-
};
|
|
954
|
-
});
|
|
955
1243
|
// TLC evaluates a substitute at startup and rejects it only when that fails and the level bound it
|
|
956
1244
|
// computes is above constant. The bound counts the operators that TLC's Java code overrides with
|
|
957
1245
|
// a minimum level as state-level, so the analyzer takes them for variables.
|
|
@@ -981,18 +1269,41 @@ export const createEnvironment = (
|
|
|
981
1269
|
analyzer.analyzeDefinition(definition, new Map()).level > 0
|
|
982
1270
|
? getEvaluationError(definition.body)
|
|
983
1271
|
: undefined;
|
|
984
|
-
// TLC adds the reason unless a standard module's Java code failed.
|
|
985
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}`;
|
|
986
1275
|
throw new TlaConfigError(
|
|
987
|
-
`The configuration file substitutes constant ${name} with non-constant ${target}${
|
|
1276
|
+
`The configuration file substitutes constant ${name} with non-constant ${target}${addendum}`,
|
|
988
1277
|
);
|
|
989
1278
|
}
|
|
990
1279
|
});
|
|
991
|
-
|
|
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);
|
|
992
1288
|
return {
|
|
993
1289
|
environment,
|
|
994
1290
|
assumptions,
|
|
995
1291
|
variableLocations: linkedRoot.variableLocations,
|
|
996
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) ?? []),
|
|
997
1308
|
};
|
|
998
1309
|
};
|