tla-ts 0.0.3-dev.3cf2ad0 → 0.0.3-dev.3ef4193
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/README.md +16 -2
- package/dist/cli.cjs +1 -1
- package/dist/cli.js +1 -1
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +158 -8
- package/dist/index.d.ts +158 -8
- 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 -19
- package/dist/run-cli.js +1351 -19
- package/dist/transfer.cjs +88 -18
- package/dist/transfer.js +88 -18
- package/package.json +5 -1
- package/src/ast.ts +146 -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 +1539 -235
- package/src/cli-options.ts +11 -5
- package/src/cli.ts +8 -1
- package/src/codegen.ts +77 -37
- package/src/config.ts +252 -179
- package/src/dependencies.ts +2 -2
- package/src/environment.ts +524 -140
- package/src/errors.ts +224 -3
- package/src/evaluate.ts +796 -246
- package/src/exit-codes.ts +22 -43
- package/src/index.ts +1 -0
- package/src/instances.ts +19 -16
- package/src/java-overrides.ts +104 -25
- package/src/levels.ts +191 -45
- package/src/lexer.ts +37 -5
- package/src/live-check.ts +828 -0
- package/src/liveness.ts +218 -572
- package/src/obligation-expression.ts +2 -2
- package/src/obligation-source.ts +2 -0
- package/src/parallel-worker.ts +13 -4
- package/src/parallel.ts +73 -6
- package/src/parser.ts +436 -144
- 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 +1424 -415
- package/src/run-cli.ts +1200 -143
- package/src/runtime.ts +19 -1
- 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 +42 -11
- package/src/standard-modules.ts +200 -148
- package/src/standard-ranges.ts +116 -0
- package/src/state-graph.ts +180 -0
- package/src/subexpressions.ts +231 -171
- package/src/substitution-levels.ts +38 -17
- package/src/successors.ts +219 -107
- package/src/symmetry.ts +189 -53
- package/src/tableau.ts +54 -25
- package/src/tlc-ext.ts +42 -29
- package/src/tlc-messages.ts +329 -0
- package/src/tlc-module.ts +52 -43
- package/src/tlc-order.ts +73 -9
- package/src/tlc-random.ts +37 -9
- package/src/tlc-replay.ts +655 -0
- package/src/tlc-summary.ts +20 -5
- package/src/tlc-version.ts +18 -0
- package/src/transfer.ts +15 -3
- package/src/value-sources.ts +29 -0
- package/src/values.ts +708 -180
package/src/environment.ts
CHANGED
|
@@ -1,23 +1,33 @@
|
|
|
1
|
-
import
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
1
|
+
import {
|
|
2
|
+
getChildren,
|
|
3
|
+
type Assumption,
|
|
4
|
+
type Declaration,
|
|
5
|
+
type Definition,
|
|
6
|
+
type Expression,
|
|
7
|
+
type Instance,
|
|
8
|
+
type Module,
|
|
9
|
+
type OperatorParam,
|
|
10
|
+
type SourceLocation,
|
|
10
11
|
} from "./ast";
|
|
11
12
|
import { BUNDLED_MODULES } from "./bundled-modules";
|
|
12
13
|
import type { ConfigValue, ModelConfig } from "./config";
|
|
13
14
|
import type { FileSystem } from "./json";
|
|
14
|
-
import {
|
|
15
|
+
import {
|
|
16
|
+
createSanyError,
|
|
17
|
+
createMissingModuleError,
|
|
18
|
+
formatRange,
|
|
19
|
+
formatSanyWarnings,
|
|
20
|
+
TlaConfigError,
|
|
21
|
+
TlaEvaluationError,
|
|
22
|
+
TlaSyntaxError,
|
|
23
|
+
type SanyError,
|
|
24
|
+
} from "./errors";
|
|
15
25
|
import { EXIT_STATUS, setExitCode } from "./exit-codes";
|
|
16
26
|
import {
|
|
17
27
|
createBigNumberError,
|
|
18
28
|
createRealNumberError,
|
|
19
|
-
|
|
20
|
-
|
|
29
|
+
evaluate,
|
|
30
|
+
getDefinition,
|
|
21
31
|
isTlcInteger,
|
|
22
32
|
type Builtin,
|
|
23
33
|
type Environment,
|
|
@@ -28,24 +38,39 @@ import {
|
|
|
28
38
|
renameLocals,
|
|
29
39
|
withLetInstances,
|
|
30
40
|
} from "./instances";
|
|
31
|
-
import { overrideDefinitions } from "./java-overrides";
|
|
41
|
+
import { overrideDefinitions, type JavaOverride } from "./java-overrides";
|
|
32
42
|
import { extractModule, parseModule } from "./parser";
|
|
33
43
|
import {
|
|
34
|
-
checkRedefinitions,
|
|
35
44
|
getArity,
|
|
45
|
+
getParamArities,
|
|
36
46
|
isBefore,
|
|
47
|
+
isTheoremDefinition,
|
|
37
48
|
KEY_SEPARATOR,
|
|
38
49
|
LOCAL_RESOLUTION,
|
|
50
|
+
MODULE_START,
|
|
39
51
|
resolveModule,
|
|
40
52
|
resolveSubstitutions,
|
|
53
|
+
type ModuleReport,
|
|
41
54
|
type ModuleSymbol,
|
|
55
|
+
type ModuleUnit,
|
|
56
|
+
type SymbolKind,
|
|
42
57
|
type Symbols,
|
|
43
58
|
} from "./resolve";
|
|
44
59
|
import { createRuntime } from "./runtime";
|
|
45
|
-
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";
|
|
46
69
|
import { resolveInstanceSubexpressions, resolveModuleSubexpressions } from "./subexpressions";
|
|
47
|
-
import { checkModuleLevels } from "./levels";
|
|
48
|
-
import {
|
|
70
|
+
import { checkModuleLevels, createLevelAnalyzer } from "./levels";
|
|
71
|
+
import { createInstanceChecker, type InstanceCheck } from "./substitution-levels";
|
|
72
|
+
import { isEvalException } from "./tlc-messages";
|
|
73
|
+
import { createTlcDefinitionOrder, getTlcDeclarationOrder } from "./tlc-order";
|
|
49
74
|
import {
|
|
50
75
|
checkInteger,
|
|
51
76
|
createModelValue,
|
|
@@ -53,7 +78,9 @@ import {
|
|
|
53
78
|
formatValue,
|
|
54
79
|
valuesEqual,
|
|
55
80
|
type Value,
|
|
81
|
+
markNormalized,
|
|
56
82
|
} from "./values";
|
|
83
|
+
import type { TlcVersion } from "./tlc-version";
|
|
57
84
|
|
|
58
85
|
interface EnvironmentOptions {
|
|
59
86
|
source: string;
|
|
@@ -62,6 +89,15 @@ interface EnvironmentOptions {
|
|
|
62
89
|
print: (text: string) => void;
|
|
63
90
|
files: FileSystem;
|
|
64
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;
|
|
65
101
|
}
|
|
66
102
|
|
|
67
103
|
interface Specification {
|
|
@@ -69,6 +105,12 @@ interface Specification {
|
|
|
69
105
|
assumptions: Assumption[];
|
|
70
106
|
variableLocations: SourceLocation[];
|
|
71
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[];
|
|
72
114
|
}
|
|
73
115
|
|
|
74
116
|
export interface InstanceAction {
|
|
@@ -104,25 +146,73 @@ interface LinkedModule {
|
|
|
104
146
|
exported: Symbols;
|
|
105
147
|
modules: Map<string, LinkedModule>;
|
|
106
148
|
extended: LinkedModule[];
|
|
149
|
+
facts: Set<string>;
|
|
107
150
|
}
|
|
108
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.
|
|
109
154
|
interface ModuleScope {
|
|
110
155
|
id: string;
|
|
111
156
|
symbols: Symbols;
|
|
112
157
|
modules: Map<string, LinkedModule>;
|
|
113
158
|
nested: Module[];
|
|
159
|
+
errors: SanyError[];
|
|
160
|
+
warnings: SanyError[];
|
|
161
|
+
levelChecks: (() => void)[];
|
|
114
162
|
}
|
|
115
163
|
|
|
116
|
-
const getDeclarations = (linked: LinkedModule) => [
|
|
164
|
+
const getDeclarations = (linked: LinkedModule): Declaration[] => [
|
|
117
165
|
...linked.constants,
|
|
118
|
-
...linked.variables.map((variable) => ({
|
|
166
|
+
...linked.variables.map((variable, index) => ({
|
|
167
|
+
name: variable,
|
|
168
|
+
arity: 0,
|
|
169
|
+
location: linked.variableLocations[index],
|
|
170
|
+
})),
|
|
119
171
|
];
|
|
120
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
|
+
|
|
121
195
|
const createModuleRedefinedError = (module: Module) =>
|
|
122
196
|
new TlaSyntaxError(
|
|
123
197
|
`Multiply-defined module '${module.name}' at line ${module.location.line}, column ${module.location.column}`,
|
|
124
198
|
);
|
|
125
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
|
+
|
|
126
216
|
const createLocalFunction = (definition: Definition, key: string): Definition => ({
|
|
127
217
|
kind: "Operator",
|
|
128
218
|
name: key,
|
|
@@ -212,13 +302,21 @@ export const createEnvironment = (
|
|
|
212
302
|
const root = parseModule(options.source);
|
|
213
303
|
const definitions = new Map<string, Definition>();
|
|
214
304
|
const parameterized = new Map<string, boolean>();
|
|
305
|
+
// The definition each instance copy came from, and the instance parameters the copy adds.
|
|
306
|
+
const copySources = new Map<string, { source: string; prefix: number }>();
|
|
307
|
+
const substitutedDefinitions = new Set<Definition>();
|
|
215
308
|
const builtins = new Map<string, Builtin>(
|
|
216
309
|
CORE_OPERATORS.map((operator) => [operator.name, operator]),
|
|
217
310
|
);
|
|
218
311
|
const standardExports = new Map<string, Symbols>();
|
|
219
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";
|
|
220
316
|
const linkedModules = new Map<string, LinkedModule>();
|
|
221
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>();
|
|
222
320
|
const linkedList: LinkedModule[] = [];
|
|
223
321
|
const dependencies = new Map<string, Set<string>>();
|
|
224
322
|
const loading: Set<string>[] = [];
|
|
@@ -233,13 +331,35 @@ export const createEnvironment = (
|
|
|
233
331
|
const copyCount = { value: 0 };
|
|
234
332
|
const createName = (name: string) => `${name}#${copyCount.value++}`;
|
|
235
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
|
+
});
|
|
236
351
|
const instanceActions = new Map<string, InstanceAction>();
|
|
352
|
+
const instanceNames = new Map<string, string>();
|
|
353
|
+
const qualifiedNames = new Map<string, string>();
|
|
237
354
|
|
|
238
355
|
const addStandardModule = (name: string): Symbols | undefined => {
|
|
239
356
|
const cached = standardExports.get(name);
|
|
240
357
|
if (cached) return cached;
|
|
241
|
-
const standardModule = getStandardModule(name, options.print, runtime, options.files);
|
|
358
|
+
const standardModule = getStandardModule(name, options.print, runtime, options.files, builtins);
|
|
242
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);
|
|
243
363
|
const exported: Symbols = new Map();
|
|
244
364
|
standardModule.extends.forEach((extended) =>
|
|
245
365
|
addStandardModule(extended)?.forEach((symbol, symbolName) =>
|
|
@@ -248,7 +368,13 @@ export const createEnvironment = (
|
|
|
248
368
|
);
|
|
249
369
|
standardModule.operators.forEach((operator) => {
|
|
250
370
|
builtins.set(operator.name, operator);
|
|
251
|
-
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
|
+
});
|
|
252
378
|
});
|
|
253
379
|
standardExports.set(name, exported);
|
|
254
380
|
return exported;
|
|
@@ -256,7 +382,11 @@ export const createEnvironment = (
|
|
|
256
382
|
|
|
257
383
|
const getStandardSymbols = (name: string) => {
|
|
258
384
|
const symbols = addStandardModule(name);
|
|
259
|
-
|
|
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");
|
|
260
390
|
return symbols;
|
|
261
391
|
};
|
|
262
392
|
|
|
@@ -284,14 +414,17 @@ export const createEnvironment = (
|
|
|
284
414
|
options.loadModule?.(name) ??
|
|
285
415
|
BUNDLED_MODULES.get(name) ??
|
|
286
416
|
extractModule(options.source, name);
|
|
287
|
-
if (source === undefined)
|
|
288
|
-
|
|
289
|
-
`Cannot find source file for module ${name} imported in module ${importer}.`,
|
|
290
|
-
);
|
|
291
|
-
const module = parseModule(source);
|
|
417
|
+
if (source === undefined) throw createMissingModuleError(name, importer);
|
|
418
|
+
const module = parseModuleFile(source, name);
|
|
292
419
|
if (module.name !== name) {
|
|
293
|
-
throw
|
|
294
|
-
|
|
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,
|
|
295
428
|
);
|
|
296
429
|
}
|
|
297
430
|
return rejectModuleLiterals(module);
|
|
@@ -307,6 +440,8 @@ export const createEnvironment = (
|
|
|
307
440
|
}
|
|
308
441
|
const closure = new Set<string>();
|
|
309
442
|
const nested: Module[] = [];
|
|
443
|
+
const errors: SanyError[] = [];
|
|
444
|
+
const levelChecks: (() => void)[] = [];
|
|
310
445
|
linking.push(parsed.name);
|
|
311
446
|
loading.push(closure);
|
|
312
447
|
const linked = linkModule(parsed, {
|
|
@@ -314,11 +449,19 @@ export const createEnvironment = (
|
|
|
314
449
|
symbols: new Map(),
|
|
315
450
|
modules: new Map(),
|
|
316
451
|
nested,
|
|
452
|
+
errors,
|
|
453
|
+
warnings,
|
|
454
|
+
levelChecks,
|
|
317
455
|
});
|
|
318
456
|
loading.pop();
|
|
319
457
|
linking.pop();
|
|
458
|
+
if (errors.length > 0) throw createSanyError(errors, false, undefined, warnings);
|
|
320
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);
|
|
321
463
|
if (duplicate) throw createModuleRedefinedError(duplicate);
|
|
464
|
+
levelChecks.forEach((check) => check());
|
|
322
465
|
return { linked, closure };
|
|
323
466
|
};
|
|
324
467
|
|
|
@@ -338,23 +481,16 @@ export const createEnvironment = (
|
|
|
338
481
|
const instantiate = (
|
|
339
482
|
instance: Instance,
|
|
340
483
|
module: Module,
|
|
341
|
-
unit:
|
|
342
|
-
imported: Symbols;
|
|
343
|
-
importedAt: Map<string, SourceLocation>;
|
|
344
|
-
definitions: Map<string, Definition>;
|
|
345
|
-
getKey: (definition: Definition) => string;
|
|
346
|
-
},
|
|
484
|
+
unit: ModuleUnit,
|
|
347
485
|
isParameterFree: boolean,
|
|
348
486
|
nested: LinkedModule | undefined,
|
|
349
487
|
): Symbols => {
|
|
350
488
|
const standardSymbols = nested ? undefined : getStandardSymbols(instance.module);
|
|
351
|
-
if (standardSymbols)
|
|
352
|
-
if (instance.name === undefined) return standardSymbols;
|
|
353
|
-
return new Map(
|
|
354
|
-
[...standardSymbols].map(([name, symbol]) => [`${instance.name}!${name}`, symbol]),
|
|
355
|
-
);
|
|
356
|
-
}
|
|
489
|
+
if (standardSymbols) return getStandardInstanceSymbols(instance, standardSymbols);
|
|
357
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
|
+
);
|
|
358
494
|
const declarations = getDeclarations(linked);
|
|
359
495
|
const suffix = `#${copyCount.value++}`;
|
|
360
496
|
const renamed = new Map(instance.params.map((param) => [param.name, `${param.name}${suffix}`]));
|
|
@@ -379,35 +515,83 @@ export const createEnvironment = (
|
|
|
379
515
|
variables: new Set(linked.variables),
|
|
380
516
|
getDefinition: (key) => definitions.get(key),
|
|
381
517
|
isParameterized: (key) => parameterized.get(key) === true,
|
|
382
|
-
addDefinition: (name, create) => {
|
|
518
|
+
addDefinition: (source, name, create) => {
|
|
383
519
|
const key = createName(`${name}@${module.name}`);
|
|
384
|
-
|
|
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
|
+
}
|
|
385
526
|
parameterized.set(key, !isParameterFree);
|
|
527
|
+
copySources.set(key, { source, prefix: instance.params.length });
|
|
386
528
|
return key;
|
|
387
529
|
},
|
|
388
530
|
createName,
|
|
389
531
|
});
|
|
390
|
-
|
|
391
|
-
|
|
392
|
-
|
|
393
|
-
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
|
|
397
|
-
|
|
398
|
-
symbols.set(name, { key, arity: symbol.arity });
|
|
399
|
-
return;
|
|
400
|
-
}
|
|
401
|
-
const key = instantiation.getQualifiedKey(symbol.key);
|
|
402
|
-
if (declarations.length > 0) {
|
|
403
|
-
instanceActions.set(key, { name: `${instance.name}!${name}`, location: instance.location });
|
|
404
|
-
}
|
|
405
|
-
symbols.set(`${instance.name}!${name}`, {
|
|
406
|
-
key,
|
|
407
|
-
arity: symbol.arity + instance.params.length,
|
|
408
|
-
});
|
|
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;
|
|
409
540
|
});
|
|
410
|
-
|
|
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
|
+
);
|
|
411
595
|
};
|
|
412
596
|
|
|
413
597
|
const getLocalArguments = (params: OperatorParam[], location: SourceLocation) =>
|
|
@@ -544,7 +728,7 @@ export const createEnvironment = (
|
|
|
544
728
|
variables: new Set(linked.variables),
|
|
545
729
|
getDefinition: (key) => definitions.get(key),
|
|
546
730
|
isParameterized: (key) => parameterized.get(key) === true,
|
|
547
|
-
addDefinition: (name, create) => {
|
|
731
|
+
addDefinition: (_source, name, create) => {
|
|
548
732
|
const key = `${name}${KEY_SEPARATOR}${instance.module}${suffix}.${copies.length}`;
|
|
549
733
|
const definition = create(key);
|
|
550
734
|
copies.push(
|
|
@@ -580,31 +764,70 @@ export const createEnvironment = (
|
|
|
580
764
|
return definition ? [{ ...definition, name }] : [];
|
|
581
765
|
});
|
|
582
766
|
|
|
767
|
+
const javaOverrides = new Map<string, JavaOverride[]>();
|
|
583
768
|
const linkModule = (unlinked: Module, scope: ModuleScope): LinkedModule => {
|
|
584
|
-
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;
|
|
585
777
|
const visible: Symbols = new Map([
|
|
586
778
|
...CORE_OPERATORS.map((operator): [string, ModuleSymbol] => [
|
|
587
779
|
operator.name,
|
|
588
|
-
{ key: operator.name, arity: operator.arity },
|
|
780
|
+
{ key: operator.name, arity: operator.arity, kind: "Builtin" },
|
|
589
781
|
]),
|
|
590
782
|
...scope.symbols,
|
|
591
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
|
+
});
|
|
592
819
|
const exported: Symbols = new Map();
|
|
820
|
+
const facts = new Set<string>();
|
|
593
821
|
const modules = new Map<string, LinkedModule>();
|
|
594
822
|
const extended: LinkedModule[] = [];
|
|
595
823
|
const constants = [...parsed.constants];
|
|
596
824
|
const variables = parsed.variables.map((variable) => variable.name);
|
|
597
825
|
const variableLocations = parsed.variables.map((variable) => variable.location);
|
|
598
|
-
const addSymbols = (symbols: Symbols, isExported: boolean) =>
|
|
599
|
-
symbols.forEach((symbol, name) => {
|
|
600
|
-
visible.set(name, symbol);
|
|
601
|
-
if (isExported) exported.set(name, symbol);
|
|
602
|
-
});
|
|
603
826
|
parsed.extends.forEach((name) => {
|
|
604
827
|
const nested = scope.modules.get(name);
|
|
605
828
|
const standardSymbols = nested ? undefined : getStandardSymbols(name);
|
|
606
829
|
if (standardSymbols) {
|
|
607
|
-
|
|
830
|
+
mergeExtended(standardSymbols);
|
|
608
831
|
return;
|
|
609
832
|
}
|
|
610
833
|
const linked = nested ?? getLinkedModule(name, parsed.name);
|
|
@@ -618,61 +841,117 @@ export const createEnvironment = (
|
|
|
618
841
|
variables.push(variable);
|
|
619
842
|
variableLocations.push(linked.variableLocations[index]);
|
|
620
843
|
});
|
|
621
|
-
|
|
844
|
+
mergeExtended(linked.exported);
|
|
845
|
+
linked.facts.forEach((name) => facts.add(name));
|
|
622
846
|
linked.modules.forEach((module, moduleName) => modules.set(moduleName, module));
|
|
623
847
|
extended.push(linked);
|
|
624
848
|
});
|
|
625
|
-
|
|
626
|
-
|
|
627
|
-
|
|
628
|
-
|
|
629
|
-
|
|
630
|
-
|
|
631
|
-
|
|
632
|
-
|
|
633
|
-
|
|
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)),
|
|
634
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
|
+
});
|
|
635
870
|
const isParameterFree = constants.length === 0 && variables.length === 0;
|
|
636
871
|
const getKey = (definition: Definition) =>
|
|
637
872
|
parsed === root ? definition.name : `${definition.name}${KEY_SEPARATOR}${scope.id}`;
|
|
638
|
-
const
|
|
639
|
-
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 => ({
|
|
640
885
|
imported: visible,
|
|
641
|
-
|
|
642
|
-
|
|
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
|
+
),
|
|
643
909
|
getKey,
|
|
910
|
+
instanced,
|
|
911
|
+
facts,
|
|
912
|
+
reports,
|
|
913
|
+
warnings: scope.warnings,
|
|
644
914
|
});
|
|
645
|
-
|
|
915
|
+
// SANY keeps the first of two symbols of a name.
|
|
646
916
|
const getSymbolsBefore = (location: SourceLocation): Symbols =>
|
|
647
|
-
|
|
648
|
-
...
|
|
649
|
-
...[
|
|
650
|
-
...parsed.constants.map((constant) => ({ ...constant, kind: "Constant" as const })),
|
|
651
|
-
...parsed.variables.map((variable) => ({ ...variable, kind: "Variable" as const })),
|
|
652
|
-
]
|
|
917
|
+
[
|
|
918
|
+
...declarations
|
|
653
919
|
.filter((declaration) => isBefore(declaration.location, location))
|
|
654
920
|
.map((declaration): [string, ModuleSymbol] => [
|
|
655
921
|
declaration.name,
|
|
656
|
-
|
|
922
|
+
getDeclarationSymbol(declaration),
|
|
657
923
|
]),
|
|
658
924
|
...parsed.definitions
|
|
659
925
|
.filter((definition) => isBefore(definition.location, location))
|
|
660
926
|
.map((definition): [string, ModuleSymbol] => [
|
|
661
927
|
definition.name,
|
|
662
|
-
|
|
928
|
+
getDefinitionSymbol(definition),
|
|
663
929
|
]),
|
|
664
|
-
]
|
|
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.
|
|
665
936
|
const linkNested = (nested: Module) => {
|
|
666
937
|
const visibleModules = getVisibleModules();
|
|
667
|
-
|
|
938
|
+
const existing = visibleModules.get(nested.name);
|
|
939
|
+
const redefinition = existing && getModuleRedefinition(nested, existing.module);
|
|
940
|
+
if (existing && !redefinition) throw createModuleRedefinedError(nested);
|
|
668
941
|
scope.nested.push(nested);
|
|
942
|
+
const report: ModuleReport = { location: nested.location, errors: [], warnings: [] };
|
|
943
|
+
reports.push(report);
|
|
669
944
|
const linked = linkModule(nested, {
|
|
670
945
|
id: `${scope.id}/${nested.name}`,
|
|
671
946
|
symbols: getSymbolsBefore(nested.location),
|
|
672
947
|
modules: visibleModules,
|
|
673
948
|
nested: scope.nested,
|
|
949
|
+
errors: report.errors,
|
|
950
|
+
warnings: report.warnings,
|
|
951
|
+
levelChecks: scope.levelChecks,
|
|
674
952
|
});
|
|
675
|
-
|
|
953
|
+
if (redefinition) report.errors.push(redefinition);
|
|
954
|
+
if (!existing) modules.set(nested.name, linked);
|
|
676
955
|
if (!nestedModules.has(nested.name)) nestedModules.set(nested.name, linked);
|
|
677
956
|
};
|
|
678
957
|
[
|
|
@@ -686,10 +965,13 @@ export const createEnvironment = (
|
|
|
686
965
|
isParameterFree,
|
|
687
966
|
getVisibleModules().get(instance.module),
|
|
688
967
|
);
|
|
689
|
-
|
|
690
|
-
|
|
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);
|
|
691
974
|
});
|
|
692
|
-
addSymbols(symbols, !instance.isLocal);
|
|
693
975
|
},
|
|
694
976
|
})),
|
|
695
977
|
...parsed.modules.map((nested) => ({
|
|
@@ -699,36 +981,30 @@ export const createEnvironment = (
|
|
|
699
981
|
]
|
|
700
982
|
.sort((left, right) => (isBefore(left.location, right.location) ? -1 : 1))
|
|
701
983
|
.forEach((unit) => unit.link());
|
|
702
|
-
checkRedefinitions(parsed, getUnit(parsed));
|
|
703
|
-
const isInstancedAfterDefinition = (nested: Module) => {
|
|
704
|
-
const first = parsed.instances.find((instance) => instance.module === nested.name);
|
|
705
|
-
return first !== undefined && isBefore(nested.location, first.location);
|
|
706
|
-
};
|
|
707
|
-
const getLetModule = (instance: Instance) => {
|
|
708
|
-
const own = parsed.modules.find((nested) => nested.name === instance.module);
|
|
709
|
-
if (!own) return getVisibleModules().get(instance.module);
|
|
710
|
-
return isInstancedAfterDefinition(own) ? modules.get(own.name) : undefined;
|
|
711
|
-
};
|
|
712
984
|
const module = resolveModuleSubexpressions(
|
|
713
985
|
withLetInstances(parsed, (instance, lets) =>
|
|
714
986
|
instantiateLocally(instance, lets, parsed.name, getLetModule(instance)),
|
|
715
987
|
),
|
|
716
988
|
getAvailableDefinitions(visible),
|
|
717
989
|
);
|
|
718
|
-
resolveModule(module, getUnit(module));
|
|
990
|
+
scope.errors.push(...resolveModule(module, getUnit(module)));
|
|
719
991
|
module.definitions.forEach((definition) => {
|
|
720
992
|
const key = getKey(definition);
|
|
721
993
|
definitions.set(key, definition);
|
|
722
994
|
parameterized.set(key, !isParameterFree);
|
|
723
|
-
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
|
+
}
|
|
724
1005
|
visible.set(definition.name, symbol);
|
|
725
1006
|
if (!definition.isLocal) exported.set(definition.name, symbol);
|
|
726
1007
|
});
|
|
727
|
-
checkModuleLevels(module, {
|
|
728
|
-
constants: new Set(constants.map((constant) => constant.name)),
|
|
729
|
-
variables: new Set(variables),
|
|
730
|
-
getDefinition: (symbol) => definitions.get(visible.get(symbol)?.key ?? symbol),
|
|
731
|
-
});
|
|
732
1008
|
const linked = {
|
|
733
1009
|
module,
|
|
734
1010
|
constants,
|
|
@@ -738,12 +1014,36 @@ export const createEnvironment = (
|
|
|
738
1014
|
exported,
|
|
739
1015
|
modules,
|
|
740
1016
|
extended,
|
|
1017
|
+
facts: new Set([
|
|
1018
|
+
...facts,
|
|
1019
|
+
...[...module.theorems, ...module.assumptions].flatMap((fact) => fact.name ?? []),
|
|
1020
|
+
]),
|
|
741
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
|
+
);
|
|
742
1041
|
linkedList.push(linked);
|
|
743
1042
|
return linked;
|
|
744
1043
|
};
|
|
745
1044
|
|
|
746
1045
|
const linkedRoot = linkTopLevel(root).linked;
|
|
1046
|
+
if (warnings.length > 0 && !options.isSanyReported) options.print(formatSanyWarnings(warnings));
|
|
747
1047
|
const getRootKey = (name: string) => linkedRoot.visible.get(name)?.key ?? name;
|
|
748
1048
|
linkedRoot.visible.forEach((symbol, name) => {
|
|
749
1049
|
const definition = definitions.get(symbol.key);
|
|
@@ -785,6 +1085,7 @@ export const createEnvironment = (
|
|
|
785
1085
|
.filter((assignment) => assignment.args === undefined)
|
|
786
1086
|
.forEach((assignment) => {
|
|
787
1087
|
const value = toValue(assignment.value);
|
|
1088
|
+
markNormalized(value);
|
|
788
1089
|
getScopedKeys(assignment).forEach((key) => {
|
|
789
1090
|
const arity = getKeyArity(key);
|
|
790
1091
|
if (arity === 0) constants.set(key, value);
|
|
@@ -872,11 +1173,58 @@ export const createEnvironment = (
|
|
|
872
1173
|
);
|
|
873
1174
|
}
|
|
874
1175
|
});
|
|
875
|
-
|
|
876
|
-
|
|
877
|
-
|
|
878
|
-
|
|
1176
|
+
// TLC sets a module-scoped entry on the body of the module's definition, which every instance of
|
|
1177
|
+
// the module shares.
|
|
1178
|
+
const scopedKeys = new Set(
|
|
1179
|
+
[...config.constants, ...config.substitutions]
|
|
1180
|
+
.filter((item) => item.module !== undefined)
|
|
1181
|
+
.flatMap(getScopedKeys),
|
|
1182
|
+
);
|
|
1183
|
+
const getOverride = (
|
|
1184
|
+
key: string,
|
|
1185
|
+
prefix: number,
|
|
1186
|
+
): { key: string; prefix: number } | undefined => {
|
|
1187
|
+
if (scopedKeys.has(key)) return { key, prefix };
|
|
1188
|
+
const copy = copySources.get(key);
|
|
1189
|
+
return copy && getOverride(copy.source, prefix + copy.prefix);
|
|
1190
|
+
};
|
|
1191
|
+
copySources.forEach((copy, key) => {
|
|
1192
|
+
const override = getOverride(copy.source, copy.prefix);
|
|
1193
|
+
const definition = definitions.get(key);
|
|
1194
|
+
if (!override || !definition) return;
|
|
1195
|
+
const params = definition.kind === "Operator" ? definition.params : [];
|
|
1196
|
+
const alias = createLocalAlias(
|
|
1197
|
+
key,
|
|
1198
|
+
override.key,
|
|
1199
|
+
params,
|
|
1200
|
+
params.slice(override.prefix),
|
|
1201
|
+
definition.location,
|
|
1202
|
+
);
|
|
1203
|
+
definitions.set(key, alias);
|
|
1204
|
+
linkedRoot.visible.forEach((symbol, name) => {
|
|
1205
|
+
if (symbol.key === key && name !== key) definitions.set(name, alias);
|
|
1206
|
+
});
|
|
879
1207
|
});
|
|
1208
|
+
const unassigned = declaredConstants.filter(
|
|
1209
|
+
(name) => !constants.has(name) && !substitutions.has(name) && !operatorKeys.has(name),
|
|
1210
|
+
);
|
|
1211
|
+
if (unassigned.length > 0 && !options.isUnconfigured) {
|
|
1212
|
+
// TLC reports the first constant it finds unassigned in SANY's order of declarations.
|
|
1213
|
+
const name =
|
|
1214
|
+
getTlcDeclarationOrder(options.source, options.loadModule, "constant").find((constant) =>
|
|
1215
|
+
unassigned.includes(constant),
|
|
1216
|
+
) ?? unassigned[0];
|
|
1217
|
+
throw new TlaConfigError(
|
|
1218
|
+
`The constant parameter ${name} is not assigned a value by the configuration file.`,
|
|
1219
|
+
);
|
|
1220
|
+
}
|
|
1221
|
+
|
|
1222
|
+
if (options.isTraceRecorded) {
|
|
1223
|
+
builtins.forEach((builtin, name) => {
|
|
1224
|
+
const replacement = getTraceSpecArithmetic(builtin);
|
|
1225
|
+
if (replacement) builtins.set(name, replacement);
|
|
1226
|
+
});
|
|
1227
|
+
}
|
|
880
1228
|
|
|
881
1229
|
const environment: Environment = {
|
|
882
1230
|
runtime,
|
|
@@ -884,6 +1232,7 @@ export const createEnvironment = (
|
|
|
884
1232
|
builtins,
|
|
885
1233
|
constants,
|
|
886
1234
|
substitutions,
|
|
1235
|
+
instanceNames,
|
|
887
1236
|
variables,
|
|
888
1237
|
variableIndex: getVariableIndex(
|
|
889
1238
|
variables,
|
|
@@ -891,38 +1240,73 @@ export const createEnvironment = (
|
|
|
891
1240
|
),
|
|
892
1241
|
definitionValues: new Map(),
|
|
893
1242
|
constantLevels: new Map(),
|
|
1243
|
+
substitutedDefinitions,
|
|
894
1244
|
evaluators: new WeakMap(),
|
|
895
1245
|
};
|
|
896
|
-
|
|
897
|
-
|
|
898
|
-
|
|
899
|
-
|
|
900
|
-
|
|
901
|
-
|
|
902
|
-
|
|
903
|
-
|
|
904
|
-
|
|
905
|
-
|
|
906
|
-
assumptions: linked.module.assumptions.map((assumption) => assumption.expression),
|
|
907
|
-
getDefinition: (symbol) => definitions.get(linked.visible.get(symbol)?.key ?? symbol),
|
|
908
|
-
};
|
|
1246
|
+
// TLC evaluates a substitute at startup and rejects it only when that fails and the level bound it
|
|
1247
|
+
// computes is above constant. The bound counts the operators that TLC's Java code overrides with
|
|
1248
|
+
// a minimum level as state-level, so the analyzer takes them for variables.
|
|
1249
|
+
const analyzer = createLevelAnalyzer({
|
|
1250
|
+
constants: new Set(constants.keys()),
|
|
1251
|
+
variables: new Set([
|
|
1252
|
+
...variables,
|
|
1253
|
+
...["TLCGet", "Trace", "CounterExample"].filter((name) => builtins.has(name)),
|
|
1254
|
+
]),
|
|
1255
|
+
getDefinition: (name) => getDefinition(name, environment),
|
|
909
1256
|
});
|
|
1257
|
+
const getEvaluationError = (body: Expression) => {
|
|
1258
|
+
try {
|
|
1259
|
+
evaluate(body, { environment, scope: undefined, state: undefined, next: undefined });
|
|
1260
|
+
return undefined;
|
|
1261
|
+
} catch (error) {
|
|
1262
|
+
if (error instanceof TlaEvaluationError) return error;
|
|
1263
|
+
throw error;
|
|
1264
|
+
}
|
|
1265
|
+
};
|
|
910
1266
|
substitutions.forEach((target, name) => {
|
|
911
1267
|
const definition = definitions.get(target);
|
|
912
|
-
|
|
1268
|
+
const error =
|
|
913
1269
|
declaredConstants.includes(name) &&
|
|
914
|
-
definition &&
|
|
915
|
-
|
|
916
|
-
|
|
1270
|
+
definition?.kind === "Operator" &&
|
|
1271
|
+
definition.params.length === 0 &&
|
|
1272
|
+
analyzer.analyzeDefinition(definition, new Map()).level > 0
|
|
1273
|
+
? getEvaluationError(definition.body)
|
|
1274
|
+
: undefined;
|
|
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}`;
|
|
917
1278
|
throw new TlaConfigError(
|
|
918
|
-
`The configuration file substitutes constant ${name} with non-constant ${target}`,
|
|
1279
|
+
`The configuration file substitutes constant ${name} with non-constant ${target}${addendum}`,
|
|
919
1280
|
);
|
|
920
1281
|
}
|
|
921
1282
|
});
|
|
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);
|
|
922
1291
|
return {
|
|
923
1292
|
environment,
|
|
924
1293
|
assumptions,
|
|
925
1294
|
variableLocations: linkedRoot.variableLocations,
|
|
926
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) ?? []),
|
|
927
1311
|
};
|
|
928
1312
|
};
|