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.
- package/dist/cli.cjs +1 -1
- package/dist/cli.js +1 -1
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +163 -46
- package/dist/index.d.ts +163 -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 +5 -1
- package/src/ast.ts +51 -6
- 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 +1317 -428
- package/src/cli.ts +8 -1
- package/src/codegen.ts +68 -21
- package/src/config.ts +225 -206
- package/src/environment.ts +417 -129
- 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 +44 -28
- package/src/lexer.ts +32 -4
- 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 +405 -167
- 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 +1397 -457
- 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/substitution-levels.ts +5 -8
- 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
|
-
import {
|
|
56
|
-
import {
|
|
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) => ({
|
|
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, {
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
419
|
-
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
|
|
423
|
-
|
|
424
|
-
|
|
425
|
-
|
|
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
|
-
|
|
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
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
655
|
-
|
|
656
|
-
|
|
657
|
-
|
|
658
|
-
|
|
659
|
-
|
|
660
|
-
|
|
661
|
-
|
|
662
|
-
|
|
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
|
|
668
|
-
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 => ({
|
|
669
885
|
imported: visible,
|
|
670
|
-
|
|
671
|
-
|
|
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
|
-
|
|
915
|
+
// SANY keeps the first of two symbols of a name.
|
|
675
916
|
const getSymbolsBefore = (location: SourceLocation): Symbols =>
|
|
676
|
-
|
|
677
|
-
...
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
719
|
-
|
|
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 =
|
|
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}${
|
|
1279
|
+
`The configuration file substitutes constant ${name} with non-constant ${target}${addendum}`,
|
|
1014
1280
|
);
|
|
1015
1281
|
}
|
|
1016
1282
|
});
|
|
1017
|
-
|
|
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
|
};
|