tla-ts 0.0.3-dev.bfd303f → 0.0.3-dev.c2b256f
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 +169 -27
- package/dist/index.d.ts +169 -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 +57 -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 +1332 -262
- package/src/cli.ts +8 -1
- package/src/codegen.ts +68 -21
- package/src/config.ts +252 -179
- package/src/environment.ts +437 -123
- 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 +112 -29
- package/src/live-check.ts +204 -146
- 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 +445 -147
- 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 +1439 -411
- 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,117 @@ 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
|
-
|
|
915
|
+
// SANY keeps the first of two symbols of a name.
|
|
651
916
|
const getSymbolsBefore = (location: SourceLocation): Symbols =>
|
|
652
|
-
|
|
653
|
-
...
|
|
654
|
-
...[
|
|
655
|
-
...parsed.constants.map((constant) => ({ ...constant, kind: "Constant" as const })),
|
|
656
|
-
...parsed.variables.map((variable) => ({ ...variable, kind: "Variable" as const })),
|
|
657
|
-
]
|
|
917
|
+
[
|
|
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
|
+
].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.
|
|
670
936
|
const linkNested = (nested: Module) => {
|
|
671
937
|
const visibleModules = getVisibleModules();
|
|
672
|
-
|
|
938
|
+
const existing = visibleModules.get(nested.name);
|
|
939
|
+
const redefinition = existing && getModuleRedefinition(nested, existing.module);
|
|
940
|
+
if (existing && !redefinition) throw createModuleRedefinedError(nested);
|
|
673
941
|
scope.nested.push(nested);
|
|
942
|
+
const report: ModuleReport = { location: nested.location, errors: [], warnings: [] };
|
|
943
|
+
reports.push(report);
|
|
674
944
|
const linked = linkModule(nested, {
|
|
675
945
|
id: `${scope.id}/${nested.name}`,
|
|
676
946
|
symbols: getSymbolsBefore(nested.location),
|
|
677
947
|
modules: visibleModules,
|
|
678
948
|
nested: scope.nested,
|
|
949
|
+
errors: report.errors,
|
|
950
|
+
warnings: report.warnings,
|
|
951
|
+
levelChecks: scope.levelChecks,
|
|
679
952
|
});
|
|
680
|
-
|
|
953
|
+
if (redefinition) report.errors.push(redefinition);
|
|
954
|
+
if (!existing) modules.set(nested.name, linked);
|
|
681
955
|
if (!nestedModules.has(nested.name)) nestedModules.set(nested.name, linked);
|
|
682
956
|
};
|
|
683
957
|
[
|
|
@@ -691,10 +965,13 @@ export const createEnvironment = (
|
|
|
691
965
|
isParameterFree,
|
|
692
966
|
getVisibleModules().get(instance.module),
|
|
693
967
|
);
|
|
694
|
-
|
|
695
|
-
|
|
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);
|
|
696
974
|
});
|
|
697
|
-
addSymbols(symbols, !instance.isLocal);
|
|
698
975
|
},
|
|
699
976
|
})),
|
|
700
977
|
...parsed.modules.map((nested) => ({
|
|
@@ -704,36 +981,30 @@ export const createEnvironment = (
|
|
|
704
981
|
]
|
|
705
982
|
.sort((left, right) => (isBefore(left.location, right.location) ? -1 : 1))
|
|
706
983
|
.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
984
|
const module = resolveModuleSubexpressions(
|
|
718
985
|
withLetInstances(parsed, (instance, lets) =>
|
|
719
986
|
instantiateLocally(instance, lets, parsed.name, getLetModule(instance)),
|
|
720
987
|
),
|
|
721
988
|
getAvailableDefinitions(visible),
|
|
722
989
|
);
|
|
723
|
-
resolveModule(module, getUnit(module));
|
|
990
|
+
scope.errors.push(...resolveModule(module, getUnit(module)));
|
|
724
991
|
module.definitions.forEach((definition) => {
|
|
725
992
|
const key = getKey(definition);
|
|
726
993
|
definitions.set(key, definition);
|
|
727
994
|
parameterized.set(key, !isParameterFree);
|
|
728
|
-
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
|
+
}
|
|
729
1005
|
visible.set(definition.name, symbol);
|
|
730
1006
|
if (!definition.isLocal) exported.set(definition.name, symbol);
|
|
731
1007
|
});
|
|
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
1008
|
const linked = {
|
|
738
1009
|
module,
|
|
739
1010
|
constants,
|
|
@@ -743,12 +1014,36 @@ export const createEnvironment = (
|
|
|
743
1014
|
exported,
|
|
744
1015
|
modules,
|
|
745
1016
|
extended,
|
|
1017
|
+
facts: new Set([
|
|
1018
|
+
...facts,
|
|
1019
|
+
...[...module.theorems, ...module.assumptions].flatMap((fact) => fact.name ?? []),
|
|
1020
|
+
]),
|
|
746
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
|
+
);
|
|
747
1041
|
linkedList.push(linked);
|
|
748
1042
|
return linked;
|
|
749
1043
|
};
|
|
750
1044
|
|
|
751
1045
|
const linkedRoot = linkTopLevel(root).linked;
|
|
1046
|
+
if (warnings.length > 0 && !options.isSanyReported) options.print(formatSanyWarnings(warnings));
|
|
752
1047
|
const getRootKey = (name: string) => linkedRoot.visible.get(name)?.key ?? name;
|
|
753
1048
|
linkedRoot.visible.forEach((symbol, name) => {
|
|
754
1049
|
const definition = definitions.get(symbol.key);
|
|
@@ -790,6 +1085,7 @@ export const createEnvironment = (
|
|
|
790
1085
|
.filter((assignment) => assignment.args === undefined)
|
|
791
1086
|
.forEach((assignment) => {
|
|
792
1087
|
const value = toValue(assignment.value);
|
|
1088
|
+
markNormalized(value);
|
|
793
1089
|
getScopedKeys(assignment).forEach((key) => {
|
|
794
1090
|
const arity = getKeyArity(key);
|
|
795
1091
|
if (arity === 0) constants.set(key, value);
|
|
@@ -912,7 +1208,7 @@ export const createEnvironment = (
|
|
|
912
1208
|
const unassigned = declaredConstants.filter(
|
|
913
1209
|
(name) => !constants.has(name) && !substitutions.has(name) && !operatorKeys.has(name),
|
|
914
1210
|
);
|
|
915
|
-
if (unassigned.length > 0) {
|
|
1211
|
+
if (unassigned.length > 0 && !options.isUnconfigured) {
|
|
916
1212
|
// TLC reports the first constant it finds unassigned in SANY's order of declarations.
|
|
917
1213
|
const name =
|
|
918
1214
|
getTlcDeclarationOrder(options.source, options.loadModule, "constant").find((constant) =>
|
|
@@ -923,12 +1219,20 @@ export const createEnvironment = (
|
|
|
923
1219
|
);
|
|
924
1220
|
}
|
|
925
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
|
+
|
|
926
1229
|
const environment: Environment = {
|
|
927
1230
|
runtime,
|
|
928
1231
|
definitions,
|
|
929
1232
|
builtins,
|
|
930
1233
|
constants,
|
|
931
1234
|
substitutions,
|
|
1235
|
+
instanceNames,
|
|
932
1236
|
variables,
|
|
933
1237
|
variableIndex: getVariableIndex(
|
|
934
1238
|
variables,
|
|
@@ -936,22 +1240,9 @@ export const createEnvironment = (
|
|
|
936
1240
|
),
|
|
937
1241
|
definitionValues: new Map(),
|
|
938
1242
|
constantLevels: new Map(),
|
|
1243
|
+
substitutedDefinitions,
|
|
939
1244
|
evaluators: new WeakMap(),
|
|
940
1245
|
};
|
|
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
1246
|
// TLC evaluates a substitute at startup and rejects it only when that fails and the level bound it
|
|
956
1247
|
// computes is above constant. The bound counts the operators that TLC's Java code overrides with
|
|
957
1248
|
// a minimum level as state-level, so the analyzer takes them for variables.
|
|
@@ -981,18 +1272,41 @@ export const createEnvironment = (
|
|
|
981
1272
|
analyzer.analyzeDefinition(definition, new Map()).level > 0
|
|
982
1273
|
? getEvaluationError(definition.body)
|
|
983
1274
|
: undefined;
|
|
984
|
-
// TLC adds the reason unless a standard module's Java code failed.
|
|
985
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}`;
|
|
986
1278
|
throw new TlaConfigError(
|
|
987
|
-
`The configuration file substitutes constant ${name} with non-constant ${target}${
|
|
1279
|
+
`The configuration file substitutes constant ${name} with non-constant ${target}${addendum}`,
|
|
988
1280
|
);
|
|
989
1281
|
}
|
|
990
1282
|
});
|
|
991
|
-
|
|
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);
|
|
992
1291
|
return {
|
|
993
1292
|
environment,
|
|
994
1293
|
assumptions,
|
|
995
1294
|
variableLocations: linkedRoot.variableLocations,
|
|
996
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) ?? []),
|
|
997
1311
|
};
|
|
998
1312
|
};
|