tla-ts 0.0.3-dev.b0f84e8 → 0.0.3-dev.b4e335d
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 +150 -8
- package/dist/index.d.ts +150 -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 -20
- package/dist/run-cli.js +1351 -20
- package/dist/transfer.cjs +86 -28
- package/dist/transfer.js +86 -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 +1393 -226
- package/src/cli.ts +8 -1
- package/src/codegen.ts +68 -18
- package/src/config.ts +252 -179
- package/src/environment.ts +457 -132
- package/src/errors.ts +217 -3
- package/src/evaluate.ts +722 -112
- package/src/exit-codes.ts +5 -4
- 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 +220 -102
- package/src/liveness.ts +216 -52
- package/src/obligation-expression.ts +2 -2
- package/src/obligation-source.ts +2 -0
- package/src/parallel-worker.ts +8 -3
- package/src/parallel.ts +56 -5
- 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 +1465 -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 +3128 -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 +200 -148
- 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 +207 -103
- package/src/symmetry.ts +180 -52
- package/src/tableau.ts +54 -25
- package/src/tlc-ext.ts +13 -17
- package/src/tlc-messages.ts +329 -0
- package/src/tlc-module.ts +46 -18
- package/src/tlc-order.ts +56 -6
- 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 +697 -180
package/src/resolve.ts
CHANGED
|
@@ -4,44 +4,124 @@ import {
|
|
|
4
4
|
type AssumeProve,
|
|
5
5
|
type Bound,
|
|
6
6
|
type BoundPattern,
|
|
7
|
+
type Declaration,
|
|
7
8
|
type Definition,
|
|
8
9
|
type Expression,
|
|
10
|
+
type Fact,
|
|
9
11
|
type Instance,
|
|
12
|
+
type LabelExpression,
|
|
10
13
|
type Module,
|
|
11
14
|
type NewSymbol,
|
|
12
15
|
type OperatorParam,
|
|
13
16
|
type Proof,
|
|
14
17
|
type ProofStep,
|
|
18
|
+
type Selector,
|
|
15
19
|
type SourceLocation,
|
|
20
|
+
type SourceRange,
|
|
16
21
|
type Theorem,
|
|
17
22
|
} from "./ast";
|
|
18
|
-
import { TlaSyntaxError } from "./errors";
|
|
23
|
+
import { formatRange, TlaSyntaxError, type SanyError } from "./errors";
|
|
19
24
|
|
|
20
|
-
|
|
21
|
-
|
|
25
|
+
// The kinds of symbol SANY tells apart when it binds a name twice. A parameter is also a bound name,
|
|
26
|
+
// and a NEW symbol has a kind for each level.
|
|
27
|
+
export type SymbolKind =
|
|
28
|
+
| "Builtin"
|
|
29
|
+
| "Constant"
|
|
30
|
+
| "Variable"
|
|
31
|
+
| "Definition"
|
|
32
|
+
| "Instance"
|
|
33
|
+
| "Theorem"
|
|
34
|
+
| "Parameter"
|
|
35
|
+
| `New${NewSymbol["level"]}`;
|
|
36
|
+
|
|
37
|
+
// range is where SANY reports the symbol, and two symbols at one range are one node to SANY. params
|
|
38
|
+
// holds the arity of each parameter of a defined operator.
|
|
39
|
+
export interface Binding {
|
|
40
|
+
kind: SymbolKind;
|
|
22
41
|
arity: number;
|
|
23
|
-
|
|
42
|
+
params?: number[];
|
|
43
|
+
range?: SourceRange;
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
export interface ModuleSymbol extends Binding {
|
|
47
|
+
key: string;
|
|
24
48
|
}
|
|
25
49
|
|
|
26
50
|
export type Symbols = Map<string, ModuleSymbol>;
|
|
27
51
|
|
|
28
|
-
|
|
52
|
+
// A named theorem or proof step whose parts a name such as foo!lab or <1>2!1 selects. isInProof
|
|
53
|
+
// holds while SANY analyzes the proof of the theorem or step.
|
|
54
|
+
interface Goal {
|
|
55
|
+
statement: Expression | AssumeProve;
|
|
56
|
+
isSuffices: boolean;
|
|
57
|
+
isInProof: boolean;
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
// isPending holds for an operator a RECURSIVE declaration names until its definition.
|
|
61
|
+
// isNonFact holds for the name of a USE, HIDE, DEFINE or INSTANCE step, which SANY takes neither as
|
|
62
|
+
// a fact nor as an expression.
|
|
63
|
+
interface LocalName extends Binding {
|
|
29
64
|
name: string;
|
|
30
|
-
arity: number;
|
|
31
65
|
parent: LocalName | undefined;
|
|
66
|
+
goal?: Goal;
|
|
67
|
+
isPending?: boolean;
|
|
68
|
+
isNonFact?: boolean;
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
// A name the module binds, from position on.
|
|
72
|
+
interface ModuleBinding extends Binding {
|
|
73
|
+
position: SourceLocation;
|
|
74
|
+
isPending?: boolean;
|
|
32
75
|
}
|
|
33
76
|
|
|
77
|
+
// errors and warnings collect what SANY reports while it goes on analyzing the unit, and bindings
|
|
78
|
+
// holds the names the module binds. A label may appear where hasLabelScope holds, in a definition, a
|
|
79
|
+
// named theorem, or a numbered step, except where isLabelForbidden holds, in the scope of a NEW in a
|
|
80
|
+
// nested ASSUME, or where isInExcept holds, in the new value of an EXCEPT. labelParams holds the
|
|
81
|
+
// names bound since the innermost definition, label, or step, which a label must take as parameters,
|
|
82
|
+
// and labels the labels there. isGenerated holds in a definition tla-ts generates for a LET INSTANCE,
|
|
83
|
+
// and in a subexpression that a name selects, which SANY analyzes where it is defined.
|
|
84
|
+
// getInstance gives what an INSTANCE in a LET or a proof instantiates.
|
|
34
85
|
interface Unit {
|
|
35
86
|
imported: Symbols;
|
|
87
|
+
getInstance: (instance: Instance) => InstancedModule;
|
|
36
88
|
definitions: Map<string, Definition>;
|
|
37
89
|
getKey: (definition: Definition) => string;
|
|
38
90
|
location: SourceLocation;
|
|
39
91
|
self: Definition | undefined;
|
|
40
92
|
facts: Set<string>;
|
|
93
|
+
goals: Map<string, Goal>;
|
|
94
|
+
bindings: Map<string, ModuleBinding>;
|
|
95
|
+
errors: SanyError[];
|
|
96
|
+
warnings: SanyError[];
|
|
97
|
+
hasLabelScope: boolean;
|
|
98
|
+
isLabelForbidden: boolean;
|
|
99
|
+
isInExcept: boolean;
|
|
100
|
+
labelParams: string[];
|
|
101
|
+
labels: Set<string>;
|
|
102
|
+
isGenerated: boolean;
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
interface SelectionError {
|
|
106
|
+
args: Expression[];
|
|
107
|
+
error: SanyError;
|
|
41
108
|
}
|
|
42
109
|
|
|
110
|
+
interface SelectionState {
|
|
111
|
+
node: Expression | NewSymbol | AssumeProve;
|
|
112
|
+
isGoal: boolean;
|
|
113
|
+
isSufficesOpen: boolean;
|
|
114
|
+
}
|
|
115
|
+
|
|
116
|
+
type Reference = Expression & { kind: "Identifier" | "Apply" | "Subexpression" };
|
|
117
|
+
|
|
43
118
|
export const LOCAL_RESOLUTION = { kind: "Local" } as const;
|
|
44
119
|
|
|
120
|
+
// The subexpressions that names select, and for a name that selects none, the error SANY reports and
|
|
121
|
+
// the arguments it analyzes before it.
|
|
122
|
+
export const selections = new WeakSet<Expression>();
|
|
123
|
+
export const selectionErrors = new WeakMap<Expression, SelectionError>();
|
|
124
|
+
|
|
45
125
|
const renamedArities = new WeakMap<Expression, number>();
|
|
46
126
|
|
|
47
127
|
export const KEY_SEPARATOR = "@";
|
|
@@ -53,7 +133,7 @@ const isKey = (name: string) => {
|
|
|
53
133
|
};
|
|
54
134
|
|
|
55
135
|
const CORE_SYMBOLS: Symbols = new Map(
|
|
56
|
-
["~>", "-+->", "\\cdot"].map((name) => [name, { key: name, arity: 2 }]),
|
|
136
|
+
["~>", "-+->", "\\cdot"].map((name) => [name, { key: name, arity: 2, kind: "Builtin" }]),
|
|
57
137
|
);
|
|
58
138
|
|
|
59
139
|
export const isBefore = (left: SourceLocation, right: SourceLocation) =>
|
|
@@ -62,6 +142,9 @@ export const isBefore = (left: SourceLocation, right: SourceLocation) =>
|
|
|
62
142
|
export const getArity = (definition: Definition) =>
|
|
63
143
|
definition.kind === "Operator" ? definition.params.length : 0;
|
|
64
144
|
|
|
145
|
+
export const getParamArities = (definition: Definition) =>
|
|
146
|
+
definition.kind === "Operator" ? definition.params.map((param) => param.arity) : [];
|
|
147
|
+
|
|
65
148
|
const isInstantiated = (definition: Definition) => definition.name.includes("!");
|
|
66
149
|
|
|
67
150
|
const lookupLocal = (scope: LocalName | undefined, name: string) => {
|
|
@@ -71,12 +154,99 @@ const lookupLocal = (scope: LocalName | undefined, name: string) => {
|
|
|
71
154
|
return undefined;
|
|
72
155
|
};
|
|
73
156
|
|
|
74
|
-
|
|
75
|
-
|
|
157
|
+
// A name the module binds before the unit and before the range, which a copy of a subexpression
|
|
158
|
+
// that a reference selects keeps from its definition.
|
|
159
|
+
const getModuleBinding = (name: string, unit: Unit, range: SourceRange | undefined) => {
|
|
160
|
+
const binding = unit.bindings.get(name);
|
|
161
|
+
return binding &&
|
|
162
|
+
isBefore(binding.position, unit.location) &&
|
|
163
|
+
(!range || isBefore(binding.position, range.start))
|
|
164
|
+
? binding
|
|
165
|
+
: undefined;
|
|
166
|
+
};
|
|
167
|
+
|
|
168
|
+
const isSameRange = (left: SourceRange | undefined, right: SourceRange | undefined) =>
|
|
169
|
+
left !== undefined && right !== undefined && formatRange(left) === formatRange(right);
|
|
170
|
+
|
|
171
|
+
// SymbolTable.addSymbol binds a name nothing binds yet. It rejects a built-in operator, a parameter
|
|
172
|
+
// or bound name already in use, and a symbol of another kind or arity than the one bound, and warns
|
|
173
|
+
// of any other duplicate. tla-ts binds a symbol SANY never sees, such as one it generates. Tells
|
|
174
|
+
// whether to bind the added symbol.
|
|
175
|
+
const isBindable = (name: string, current: Binding | undefined, added: Binding, unit: Unit) => {
|
|
176
|
+
if (current === undefined) return true;
|
|
177
|
+
if (isSameRange(current.range, added.range)) return false;
|
|
178
|
+
const range = added.range;
|
|
179
|
+
if (range === undefined || unit.isGenerated || (current.kind !== "Builtin" && !current.range)) {
|
|
180
|
+
return true;
|
|
181
|
+
}
|
|
182
|
+
const location = formatRange(range);
|
|
183
|
+
const existing = current.range && formatRange(current.range);
|
|
184
|
+
if (current.kind === "Builtin") {
|
|
185
|
+
unit.errors.push({
|
|
186
|
+
location,
|
|
187
|
+
message: `Symbol ${name} is a built-in operator, and cannot be redefined.`,
|
|
188
|
+
});
|
|
189
|
+
} else if (
|
|
190
|
+
added.kind === "Parameter" ||
|
|
191
|
+
current.kind !== added.kind ||
|
|
192
|
+
current.arity !== added.arity
|
|
193
|
+
) {
|
|
194
|
+
unit.errors.push({
|
|
195
|
+
location,
|
|
196
|
+
message: `Multiply-defined symbol '${name}': this definition or declaration conflicts \nwith the one at ${existing}.`,
|
|
197
|
+
});
|
|
198
|
+
} else {
|
|
199
|
+
unit.warnings.push({
|
|
200
|
+
location,
|
|
201
|
+
message: `Multiple declarations or definitions for symbol ${name}. \nThis duplicates the one at ${existing}.`,
|
|
202
|
+
});
|
|
203
|
+
}
|
|
204
|
+
return false;
|
|
205
|
+
};
|
|
206
|
+
|
|
207
|
+
const bindName = (
|
|
208
|
+
scope: LocalName | undefined,
|
|
209
|
+
name: string,
|
|
210
|
+
added: Binding,
|
|
211
|
+
unit: Unit,
|
|
212
|
+
): LocalName | undefined =>
|
|
213
|
+
isBindable(
|
|
214
|
+
name,
|
|
215
|
+
lookupLocal(scope, name) ?? getModuleBinding(name, unit, added.range),
|
|
216
|
+
added,
|
|
217
|
+
unit,
|
|
218
|
+
)
|
|
219
|
+
? { ...added, name, parent: scope }
|
|
220
|
+
: scope;
|
|
221
|
+
|
|
222
|
+
// Binds the names of a module from the unit on.
|
|
223
|
+
const bindModuleName = (name: string, added: Binding, unit: Unit) => {
|
|
224
|
+
if (isBindable(name, unit.bindings.get(name), added, unit)) {
|
|
225
|
+
unit.bindings.set(name, { ...added, position: unit.location });
|
|
226
|
+
}
|
|
227
|
+
};
|
|
228
|
+
|
|
229
|
+
const bindNames = (
|
|
230
|
+
scope: LocalName | undefined,
|
|
231
|
+
names: string[],
|
|
232
|
+
ranges: SourceRange[] | undefined,
|
|
233
|
+
unit: Unit,
|
|
234
|
+
) =>
|
|
235
|
+
names.reduce(
|
|
236
|
+
(parent, name, index) =>
|
|
237
|
+
bindName(parent, name, { kind: "Parameter", arity: 0, range: ranges?.[index] }, unit),
|
|
238
|
+
scope,
|
|
239
|
+
);
|
|
76
240
|
|
|
77
|
-
const bindParams = (scope: LocalName | undefined, params: OperatorParam[]) =>
|
|
78
|
-
params.reduce
|
|
79
|
-
(parent, param) =>
|
|
241
|
+
const bindParams = (scope: LocalName | undefined, params: OperatorParam[], unit: Unit) =>
|
|
242
|
+
params.reduce(
|
|
243
|
+
(parent, param) =>
|
|
244
|
+
bindName(
|
|
245
|
+
parent,
|
|
246
|
+
param.name,
|
|
247
|
+
{ kind: "Parameter", arity: param.arity, range: param.location?.range },
|
|
248
|
+
unit,
|
|
249
|
+
),
|
|
80
250
|
scope,
|
|
81
251
|
);
|
|
82
252
|
|
|
@@ -99,19 +269,452 @@ const getVisibleDefinition = (name: string, unit: Unit) => {
|
|
|
99
269
|
const findSymbol = (name: string, unit: Unit): ModuleSymbol | undefined => {
|
|
100
270
|
const definition = getVisibleDefinition(name, unit);
|
|
101
271
|
return definition
|
|
102
|
-
? {
|
|
272
|
+
? {
|
|
273
|
+
key: unit.getKey(definition),
|
|
274
|
+
arity: getArity(definition),
|
|
275
|
+
params: getParamArities(definition),
|
|
276
|
+
kind: "Definition",
|
|
277
|
+
}
|
|
103
278
|
: unit.imported.get(name);
|
|
104
279
|
};
|
|
105
280
|
|
|
281
|
+
const findBinding = (name: string, scope: LocalName | undefined, unit: Unit): Binding | undefined =>
|
|
282
|
+
lookupLocal(scope, name) ?? findSymbol(name, unit);
|
|
283
|
+
|
|
284
|
+
// SANY reports a name at the range of its text.
|
|
285
|
+
const getNameRange = (location: SourceLocation, name: string): SourceRange => ({
|
|
286
|
+
module: location.range?.module ?? "",
|
|
287
|
+
start: location,
|
|
288
|
+
end: { line: location.line, column: location.column + name.length - 1 },
|
|
289
|
+
});
|
|
290
|
+
|
|
291
|
+
// SANY reports a name at its tokens, such as M ! ⊕ for M!\oplus.
|
|
292
|
+
const getSpelledNameRange = (
|
|
293
|
+
expression: Expression & { kind: "Identifier" | "Apply" | "OperatorReference" },
|
|
294
|
+
name: string,
|
|
295
|
+
): SourceRange => {
|
|
296
|
+
const selectorRange =
|
|
297
|
+
expression.kind === "OperatorReference" ? undefined : expression.selectorRanges?.at(-1);
|
|
298
|
+
return selectorRange
|
|
299
|
+
? { module: selectorRange.module, start: expression.location, end: selectorRange.end }
|
|
300
|
+
: getNameRange(expression.location, expression.spelling ?? name);
|
|
301
|
+
};
|
|
302
|
+
|
|
303
|
+
// SANY reports an operator symbol applied to operands as one it cannot resolve.
|
|
304
|
+
const getFixity = (expression: Expression) => {
|
|
305
|
+
if (expression.kind !== "Apply") return undefined;
|
|
306
|
+
if (expression.args.length === 2) return "infix";
|
|
307
|
+
if (expression.args.length !== 1) return undefined;
|
|
308
|
+
return isBefore(expression.location, expression.args[0].location) ? "prefix" : "postfix";
|
|
309
|
+
};
|
|
310
|
+
|
|
106
311
|
// SANY names an undefined operator symbol such as + differently from an undefined identifier.
|
|
107
|
-
const isOperatorSymbol = (name: string) =>
|
|
108
|
-
name[0].toLowerCase() === name[0].toUpperCase() &&
|
|
109
|
-
name[0] !== "_" &&
|
|
110
|
-
(name[0] < "0" || name[0] > "9");
|
|
312
|
+
const isOperatorSymbol = (name: string) => !/^[\p{L}\d_]/u.test(name);
|
|
111
313
|
|
|
112
314
|
const isStepName = (name: string) =>
|
|
113
315
|
name.startsWith("<") && ((name[1] >= "0" && name[1] <= "9") || name[1] === "*");
|
|
114
316
|
|
|
317
|
+
export const getOperandIndex = (operand: number | "<<" | ">>", count: number) => {
|
|
318
|
+
if (typeof operand === "number") return operand >= 1 && operand <= count ? operand - 1 : -1;
|
|
319
|
+
if (operand === "<<") return count > 0 ? 0 : -1;
|
|
320
|
+
return count === 2 ? 1 : -1;
|
|
321
|
+
};
|
|
322
|
+
|
|
323
|
+
// The parts of a name such as F(x)!l(y), each with its own arguments. counts holds the number each
|
|
324
|
+
// part takes, when a part before the last takes some.
|
|
325
|
+
export const getNameSelectors = (
|
|
326
|
+
name: string,
|
|
327
|
+
args: Expression[],
|
|
328
|
+
counts: number[] | undefined,
|
|
329
|
+
): Selector[] => {
|
|
330
|
+
const parts = name.split("!");
|
|
331
|
+
const partCounts =
|
|
332
|
+
counts ?? parts.map((_, index) => (index === parts.length - 1 ? args.length : 0));
|
|
333
|
+
return parts.map((part, index) => {
|
|
334
|
+
const start = partCounts.slice(0, index).reduce((sum, count) => sum + count, 0);
|
|
335
|
+
return { kind: "Name", name: part, args: args.slice(start, start + partCounts[index]) };
|
|
336
|
+
});
|
|
337
|
+
};
|
|
338
|
+
|
|
339
|
+
const getSelectors = (reference: Reference): Selector[] =>
|
|
340
|
+
reference.kind === "Subexpression"
|
|
341
|
+
? reference.selectors
|
|
342
|
+
: reference.kind === "Identifier"
|
|
343
|
+
? getNameSelectors(reference.name, [], undefined)
|
|
344
|
+
: getNameSelectors(reference.operator, reference.args, reference.argumentCounts);
|
|
345
|
+
|
|
346
|
+
const getBoundSets = (bounds: Bound[]) =>
|
|
347
|
+
bounds
|
|
348
|
+
.filter((bound, index) => index === 0 || bounds[index - 1].set !== bound.set)
|
|
349
|
+
.map((bound) => bound.set);
|
|
350
|
+
|
|
351
|
+
// The names a binder binds, its body, and the sets it binds them to, which a selector such as !1
|
|
352
|
+
// chooses from.
|
|
353
|
+
export const getBinder = (
|
|
354
|
+
expression: Expression,
|
|
355
|
+
): { names: string[]; body: Expression; sets: Expression[] } | undefined => {
|
|
356
|
+
switch (expression.kind) {
|
|
357
|
+
case "Forall":
|
|
358
|
+
case "Exists":
|
|
359
|
+
case "FunctionConstruction":
|
|
360
|
+
return {
|
|
361
|
+
names: getBoundNames(expression.bounds),
|
|
362
|
+
body: expression.body,
|
|
363
|
+
sets: getBoundSets(expression.bounds),
|
|
364
|
+
};
|
|
365
|
+
case "SetMap":
|
|
366
|
+
return {
|
|
367
|
+
names: getBoundNames(expression.bounds),
|
|
368
|
+
body: expression.expression,
|
|
369
|
+
sets: getBoundSets(expression.bounds),
|
|
370
|
+
};
|
|
371
|
+
case "SetFilter":
|
|
372
|
+
return {
|
|
373
|
+
names: getPatternNames(expression.bound.pattern),
|
|
374
|
+
body: expression.predicate,
|
|
375
|
+
sets: [expression.bound.set],
|
|
376
|
+
};
|
|
377
|
+
case "Choose":
|
|
378
|
+
return {
|
|
379
|
+
names: getPatternNames(expression.pattern),
|
|
380
|
+
body: expression.body,
|
|
381
|
+
sets: expression.set ? [expression.set] : [],
|
|
382
|
+
};
|
|
383
|
+
case "UnboundedQuantifier":
|
|
384
|
+
case "Lambda":
|
|
385
|
+
return {
|
|
386
|
+
names: expression.kind === "Lambda" ? expression.params : expression.names,
|
|
387
|
+
body: expression.body,
|
|
388
|
+
sets: [],
|
|
389
|
+
};
|
|
390
|
+
default:
|
|
391
|
+
return undefined;
|
|
392
|
+
}
|
|
393
|
+
};
|
|
394
|
+
|
|
395
|
+
// The operands that a selector such as !1 chooses from, where they do not depend on bound names.
|
|
396
|
+
export const getOperands = (expression: Expression): Expression[] | undefined => {
|
|
397
|
+
switch (expression.kind) {
|
|
398
|
+
case "Apply":
|
|
399
|
+
return expression.args;
|
|
400
|
+
case "And":
|
|
401
|
+
case "Or":
|
|
402
|
+
return expression.operands;
|
|
403
|
+
case "If":
|
|
404
|
+
return [expression.condition, expression.consequent, expression.alternative];
|
|
405
|
+
case "Tuple":
|
|
406
|
+
case "SetEnumeration":
|
|
407
|
+
return expression.elements;
|
|
408
|
+
case "Record":
|
|
409
|
+
case "RecordSet":
|
|
410
|
+
return expression.fields.map((field) => field.value);
|
|
411
|
+
case "FunctionApplication":
|
|
412
|
+
return [
|
|
413
|
+
expression.function,
|
|
414
|
+
expression.args.length === 1
|
|
415
|
+
? expression.args[0]
|
|
416
|
+
: { kind: "Tuple", elements: expression.args, location: expression.location },
|
|
417
|
+
];
|
|
418
|
+
case "FieldAccess":
|
|
419
|
+
return [
|
|
420
|
+
expression.record,
|
|
421
|
+
{ kind: "String", value: expression.field, location: expression.location },
|
|
422
|
+
];
|
|
423
|
+
case "Prime":
|
|
424
|
+
case "Unchanged":
|
|
425
|
+
case "Enabled":
|
|
426
|
+
case "Always":
|
|
427
|
+
case "Eventually":
|
|
428
|
+
return [expression.expression];
|
|
429
|
+
case "BoxAction":
|
|
430
|
+
case "AngleAction":
|
|
431
|
+
return [expression.action, expression.subscript];
|
|
432
|
+
case "WeakFairness":
|
|
433
|
+
case "StrongFairness":
|
|
434
|
+
return [expression.subscript, expression.action];
|
|
435
|
+
case "FunctionSet":
|
|
436
|
+
return [expression.domain, expression.range];
|
|
437
|
+
case "Product":
|
|
438
|
+
return expression.factors;
|
|
439
|
+
case "Except":
|
|
440
|
+
return [expression.function];
|
|
441
|
+
default:
|
|
442
|
+
return undefined;
|
|
443
|
+
}
|
|
444
|
+
};
|
|
445
|
+
|
|
446
|
+
const isReference = (expression: Expression): expression is Reference =>
|
|
447
|
+
expression.kind === "Identifier" ||
|
|
448
|
+
expression.kind === "Apply" ||
|
|
449
|
+
expression.kind === "Subexpression";
|
|
450
|
+
|
|
451
|
+
const isInScopeOfDeclaration = (assumeProve: AssumeProve, clause: number) =>
|
|
452
|
+
assumeProve.assumptions.slice(0, clause).some((assumption) => assumption.kind === "NewSymbol");
|
|
453
|
+
|
|
454
|
+
const findLabel = (expression: Expression, name: string): LabelExpression | undefined => {
|
|
455
|
+
if (expression.kind === "Label") return expression.name === name ? expression : undefined;
|
|
456
|
+
if (expression.kind === "Lambda") return undefined;
|
|
457
|
+
if (expression.kind === "Let") return findLabel(expression.body, name);
|
|
458
|
+
return getChildren(expression).reduce<LabelExpression | undefined>(
|
|
459
|
+
(found, child) => found ?? findLabel(child, name),
|
|
460
|
+
undefined,
|
|
461
|
+
);
|
|
462
|
+
};
|
|
463
|
+
|
|
464
|
+
// SANY drops a label in the scope of a NEW in a nested ASSUME, after it reports the label.
|
|
465
|
+
const findClauseLabel = (
|
|
466
|
+
clause: Expression | NewSymbol | AssumeProve,
|
|
467
|
+
name: string,
|
|
468
|
+
isForbidden: boolean,
|
|
469
|
+
): LabelExpression | undefined => {
|
|
470
|
+
if (clause.kind === "AssumeProve") {
|
|
471
|
+
return [...clause.assumptions, clause.conclusion].reduce<LabelExpression | undefined>(
|
|
472
|
+
(found, inner, index) =>
|
|
473
|
+
found ?? findClauseLabel(inner, name, isForbidden || isInScopeOfDeclaration(clause, index)),
|
|
474
|
+
undefined,
|
|
475
|
+
);
|
|
476
|
+
}
|
|
477
|
+
if (isForbidden) return undefined;
|
|
478
|
+
if (clause.kind === "NewSymbol") return clause.set && findLabel(clause.set, name);
|
|
479
|
+
return findLabel(clause, name);
|
|
480
|
+
};
|
|
481
|
+
|
|
482
|
+
const getLabelBody = (expression: Expression): Expression =>
|
|
483
|
+
expression.kind === "Label" ? getLabelBody(expression.body) : expression;
|
|
484
|
+
|
|
485
|
+
const getOperandName = (operand: number | "<<" | ">>") =>
|
|
486
|
+
typeof operand === "number" ? `argument selector ${operand}` : operand;
|
|
487
|
+
|
|
488
|
+
const SCOPE_MESSAGE = "within the scope of a declaration\n from outside that declaration's scope.";
|
|
489
|
+
|
|
490
|
+
// Generator.selectorToNode for a name that selects part of a theorem or step. A part in the scope of
|
|
491
|
+
// a NEW in its ASSUME may be selected only within the proof of the theorem, or only after the proof
|
|
492
|
+
// of a SUFFICES step. A label takes its own arguments, and an operand must exist, unless the part
|
|
493
|
+
// selected depends on bound names. A fact may select an ASSUME/PROVE or a NEW clause.
|
|
494
|
+
const checkSelection = (
|
|
495
|
+
reference: Reference,
|
|
496
|
+
selectors: Selector[],
|
|
497
|
+
goal: Goal,
|
|
498
|
+
scope: LocalName | undefined,
|
|
499
|
+
unit: Unit,
|
|
500
|
+
isFact: boolean,
|
|
501
|
+
) => {
|
|
502
|
+
const report = (index: number | undefined, message: string) => {
|
|
503
|
+
const range =
|
|
504
|
+
(index === undefined ? undefined : reference.selectorRanges?.[index]) ??
|
|
505
|
+
reference.location.range;
|
|
506
|
+
if (range) unit.errors.push({ location: formatRange(range), message });
|
|
507
|
+
};
|
|
508
|
+
const isOutOfScope = goal.isSuffices === goal.isInProof;
|
|
509
|
+
const statement = goal.statement;
|
|
510
|
+
const state: SelectionState = {
|
|
511
|
+
node: statement,
|
|
512
|
+
isGoal: true,
|
|
513
|
+
isSufficesOpen: goal.isSuffices,
|
|
514
|
+
};
|
|
515
|
+
for (const [offset, selector] of selectors.slice(1).entries()) {
|
|
516
|
+
const index = offset + 1;
|
|
517
|
+
const node = state.node;
|
|
518
|
+
if (selector.kind === "Name") {
|
|
519
|
+
if (selectors[index - 1].kind !== "Name") {
|
|
520
|
+
const isLet =
|
|
521
|
+
node.kind !== "NewSymbol" &&
|
|
522
|
+
node.kind !== "AssumeProve" &&
|
|
523
|
+
getLabelBody(node).kind === "Let";
|
|
524
|
+
return isLet
|
|
525
|
+
? undefined
|
|
526
|
+
: report(index - 1, "A name selector here must be from a LET clause.");
|
|
527
|
+
}
|
|
528
|
+
const clauses =
|
|
529
|
+
statement.kind === "AssumeProve"
|
|
530
|
+
? [...statement.assumptions, statement.conclusion]
|
|
531
|
+
: [statement];
|
|
532
|
+
const found =
|
|
533
|
+
index === 1
|
|
534
|
+
? clauses
|
|
535
|
+
.map((clause, position) => ({
|
|
536
|
+
position,
|
|
537
|
+
label: findClauseLabel(clause, selector.name, false),
|
|
538
|
+
}))
|
|
539
|
+
.find((item) => item.label !== undefined)
|
|
540
|
+
: {
|
|
541
|
+
position: 0,
|
|
542
|
+
label: node.kind === "Label" ? findLabel(node.body, selector.name) : undefined,
|
|
543
|
+
};
|
|
544
|
+
if (!found?.label) return report(index, `Cannot find label \`${selector.name}'.`);
|
|
545
|
+
if (
|
|
546
|
+
index === 1 &&
|
|
547
|
+
statement.kind === "AssumeProve" &&
|
|
548
|
+
isInScopeOfDeclaration(statement, found.position) &&
|
|
549
|
+
isOutOfScope
|
|
550
|
+
) {
|
|
551
|
+
return report(
|
|
552
|
+
1,
|
|
553
|
+
`Accessing subexpression labeled \`${selector.name}' of ASSUME/PROVE clause ${SCOPE_MESSAGE}`,
|
|
554
|
+
);
|
|
555
|
+
}
|
|
556
|
+
if (selector.args.length !== found.label.params.length) {
|
|
557
|
+
return report(index, `Label \`${selector.name}' used with wrong number of arguments.`);
|
|
558
|
+
}
|
|
559
|
+
state.node = found.label;
|
|
560
|
+
state.isGoal = false;
|
|
561
|
+
state.isSufficesOpen = false;
|
|
562
|
+
continue;
|
|
563
|
+
}
|
|
564
|
+
if (selector.kind !== "Operand") return;
|
|
565
|
+
const operand = getOperandName(selector.operand);
|
|
566
|
+
if (state.isSufficesOpen) {
|
|
567
|
+
if (getOperandIndex(selector.operand, 1) !== 0) {
|
|
568
|
+
return report(
|
|
569
|
+
index,
|
|
570
|
+
node.kind === "AssumeProve"
|
|
571
|
+
? "Accessing non-existent subexpression of a SUFFICES"
|
|
572
|
+
: `Nonexistent operand specified by \`${operand}'.`,
|
|
573
|
+
);
|
|
574
|
+
}
|
|
575
|
+
state.isSufficesOpen = false;
|
|
576
|
+
continue;
|
|
577
|
+
}
|
|
578
|
+
if (node.kind === "NewSymbol") return;
|
|
579
|
+
if (node.kind !== "AssumeProve") {
|
|
580
|
+
const expression = getLabelBody(node);
|
|
581
|
+
if (["Number", "Decimal", "String"].includes(expression.kind)) {
|
|
582
|
+
return report(index, "Selecting subexpression of expression that has none.");
|
|
583
|
+
}
|
|
584
|
+
const kind =
|
|
585
|
+
expression.kind === "Identifier"
|
|
586
|
+
? findBinding(expression.name, scope, unit)?.kind
|
|
587
|
+
: undefined;
|
|
588
|
+
if (kind === "Variable" || kind?.startsWith("New")) {
|
|
589
|
+
return report(index, `Choosing operand \`${operand}' of subexpression with no operands.`);
|
|
590
|
+
}
|
|
591
|
+
const sets = getBinder(expression)?.sets;
|
|
592
|
+
const operands =
|
|
593
|
+
expression.kind === "Identifier"
|
|
594
|
+
? []
|
|
595
|
+
: sets
|
|
596
|
+
? sets.length > 0
|
|
597
|
+
? sets
|
|
598
|
+
: undefined
|
|
599
|
+
: expression.kind === "Except"
|
|
600
|
+
? undefined
|
|
601
|
+
: getOperands(expression);
|
|
602
|
+
if (!operands) return;
|
|
603
|
+
const position = getOperandIndex(selector.operand, operands.length);
|
|
604
|
+
if (position === -1) return report(index, `Nonexistent operand specified by \`${operand}'.`);
|
|
605
|
+
state.node = operands[position];
|
|
606
|
+
state.isGoal = false;
|
|
607
|
+
continue;
|
|
608
|
+
}
|
|
609
|
+
const clauses = [...node.assumptions, node.conclusion];
|
|
610
|
+
const position = getOperandIndex(selector.operand, clauses.length);
|
|
611
|
+
if (position === -1) return report(index, `Nonexistent operand specified by \`${operand}'.`);
|
|
612
|
+
if (isInScopeOfDeclaration(node, position) && (!state.isGoal || isOutOfScope)) {
|
|
613
|
+
return report(index, `Accessing ASSUME/PROVE clause ${SCOPE_MESSAGE}`);
|
|
614
|
+
}
|
|
615
|
+
const clause = clauses[position];
|
|
616
|
+
if (clause.kind === "NewSymbol" && index !== selectors.length - 1) {
|
|
617
|
+
return report(index, "Selected a subexpression of a NEW clause of an ASSUME.");
|
|
618
|
+
}
|
|
619
|
+
state.node = clause;
|
|
620
|
+
state.isGoal = false;
|
|
621
|
+
}
|
|
622
|
+
if (isFact) return;
|
|
623
|
+
if (state.node.kind === "AssumeProve") {
|
|
624
|
+
report(undefined, "Selected ASSUME/PROVE instead of expression.");
|
|
625
|
+
}
|
|
626
|
+
if (state.node.kind === "NewSymbol") {
|
|
627
|
+
report(undefined, "Selected a NEW declaration as an expression or operator.");
|
|
628
|
+
}
|
|
629
|
+
};
|
|
630
|
+
|
|
631
|
+
// Generator.generateLabel reports a label where it may not appear, and skips the label's body.
|
|
632
|
+
const isLabelReported = (label: LabelExpression, unit: Unit) => {
|
|
633
|
+
const message = unit.isGenerated
|
|
634
|
+
? undefined
|
|
635
|
+
: !unit.hasLabelScope
|
|
636
|
+
? "Label not in definition or proof step."
|
|
637
|
+
: unit.isLabelForbidden
|
|
638
|
+
? "Label not allowed within scope of declaration in nested ASSUME/PROVE."
|
|
639
|
+
: unit.isInExcept
|
|
640
|
+
? "Labels inside EXCEPT clauses are not yet implemented."
|
|
641
|
+
: undefined;
|
|
642
|
+
if (message === undefined || !label.location.range) return false;
|
|
643
|
+
unit.errors.push({ location: formatRange(label.location.range), message });
|
|
644
|
+
return true;
|
|
645
|
+
};
|
|
646
|
+
|
|
647
|
+
// Generator.generateLabel reports, after the label's body, each parameter that names no bound name,
|
|
648
|
+
// then formalParamsEqual each parameter given twice, each name bound since the label scope began
|
|
649
|
+
// that the label leaves out, and the parameters it adds, and then a label of a name already used.
|
|
650
|
+
const checkLabel = (label: LabelExpression, scope: LocalName | undefined, unit: Unit) => {
|
|
651
|
+
const range = label.location.range;
|
|
652
|
+
if (!range || unit.isGenerated) return;
|
|
653
|
+
const location = formatRange(range);
|
|
654
|
+
const legal = label.params.filter((param, index) => {
|
|
655
|
+
const isLegal = lookupLocal(scope, param)?.kind === "Parameter";
|
|
656
|
+
const paramRange = label.paramRanges?.[index];
|
|
657
|
+
if (!isLegal && paramRange) {
|
|
658
|
+
unit.errors.push({
|
|
659
|
+
location: formatRange(paramRange),
|
|
660
|
+
message: `Illegal parameter ${param} of label \`${label.name}'.`,
|
|
661
|
+
});
|
|
662
|
+
}
|
|
663
|
+
return isLegal;
|
|
664
|
+
});
|
|
665
|
+
legal
|
|
666
|
+
.filter((param, index) => legal.indexOf(param) !== index)
|
|
667
|
+
.forEach((param) =>
|
|
668
|
+
unit.errors.push({
|
|
669
|
+
location,
|
|
670
|
+
message: `Repeated formal parameter ${param} \nin label \`${label.name}'.`,
|
|
671
|
+
}),
|
|
672
|
+
);
|
|
673
|
+
unit.labelParams
|
|
674
|
+
.filter((param) => !legal.includes(param))
|
|
675
|
+
.forEach((param) =>
|
|
676
|
+
unit.errors.push({
|
|
677
|
+
location,
|
|
678
|
+
message: `Label ${label.name} must contain formal parameter \`${param}'.`,
|
|
679
|
+
}),
|
|
680
|
+
);
|
|
681
|
+
const extra = [
|
|
682
|
+
...new Set(legal.filter((param) => !unit.labelParams.includes(param))),
|
|
683
|
+
...label.params.filter((param) => !legal.includes(param)),
|
|
684
|
+
];
|
|
685
|
+
if (extra.length > 0) {
|
|
686
|
+
unit.errors.push({
|
|
687
|
+
location,
|
|
688
|
+
message: `Label ${label.name} declares extra parameter(s) ${extra.map((param) => `${param} `).join("")}`,
|
|
689
|
+
});
|
|
690
|
+
}
|
|
691
|
+
if (unit.labels.has(label.name)) {
|
|
692
|
+
unit.errors.push({ location, message: `Duplicate label \`${label.name}'.` });
|
|
693
|
+
}
|
|
694
|
+
unit.labels.add(label.name);
|
|
695
|
+
};
|
|
696
|
+
|
|
697
|
+
// Checks a name that selects part of a theorem or step, and tells whether it is one.
|
|
698
|
+
const checkReference = (
|
|
699
|
+
expression: Expression,
|
|
700
|
+
scope: LocalName | undefined,
|
|
701
|
+
unit: Unit,
|
|
702
|
+
isFact: boolean,
|
|
703
|
+
) => {
|
|
704
|
+
if (!isReference(expression)) return false;
|
|
705
|
+
const selectors = getSelectors(expression);
|
|
706
|
+
const first = selectors[0];
|
|
707
|
+
const goal =
|
|
708
|
+
selectors.length > 1 && first.kind === "Name"
|
|
709
|
+
? (lookupLocal(scope, first.name)?.goal ?? unit.goals.get(first.name))
|
|
710
|
+
: undefined;
|
|
711
|
+
if (goal) checkSelection(expression, selectors, goal, scope, unit, isFact);
|
|
712
|
+
return goal !== undefined;
|
|
713
|
+
};
|
|
714
|
+
|
|
715
|
+
// Generator.selectorToNode reports an unknown operator and goes on without analyzing its arguments,
|
|
716
|
+
// so its arity is undefined. It does the same for an operator given the wrong number of arguments,
|
|
717
|
+
// and for a name that selects nothing, after the arguments of the parts before.
|
|
115
718
|
const getSymbolArity = (
|
|
116
719
|
expression: Expression & { kind: "Identifier" | "Apply" | "OperatorReference" },
|
|
117
720
|
name: string,
|
|
@@ -119,11 +722,21 @@ const getSymbolArity = (
|
|
|
119
722
|
unit: Unit,
|
|
120
723
|
) => {
|
|
121
724
|
const location = expression.location;
|
|
725
|
+
if (isSelectionReported(expression, scope, unit)) return undefined;
|
|
122
726
|
const renamed = renamedArities.get(expression);
|
|
123
727
|
if (renamed !== undefined) return renamed;
|
|
124
728
|
if (isKey(name)) return expression.kind === "Apply" ? expression.args.length : 0;
|
|
125
|
-
if (isStepName(name)) return 0;
|
|
126
729
|
const local = lookupLocal(scope, name);
|
|
730
|
+
if (local?.isNonFact) {
|
|
731
|
+
unit.errors.push({
|
|
732
|
+
location: formatRange(getSpelledNameRange(expression, name)),
|
|
733
|
+
message: "Step number of non-expression step used as an expression.",
|
|
734
|
+
});
|
|
735
|
+
return undefined;
|
|
736
|
+
}
|
|
737
|
+
if (checkReference(expression, scope, unit, false) || (isStepName(name) && local)) {
|
|
738
|
+
return expression.kind === "Apply" ? expression.args.length : 0;
|
|
739
|
+
}
|
|
127
740
|
if (local && expression.kind !== "OperatorReference") expression.resolution = LOCAL_RESOLUTION;
|
|
128
741
|
if (local) return local.arity;
|
|
129
742
|
const symbol = findSymbol(name, unit);
|
|
@@ -135,7 +748,7 @@ const getSymbolArity = (
|
|
|
135
748
|
}
|
|
136
749
|
// A name such as Inv!P1 selects the label P1 of a definition or theorem, which takes its own
|
|
137
750
|
// arguments.
|
|
138
|
-
const prefix = name.slice(0, name.indexOf("!"));
|
|
751
|
+
const prefix = name.includes("!") ? name.slice(0, name.indexOf("!")) : "";
|
|
139
752
|
const isSelected =
|
|
140
753
|
prefix !== "" &&
|
|
141
754
|
(lookupLocal(scope, prefix) !== undefined ||
|
|
@@ -144,18 +757,35 @@ const getSymbolArity = (
|
|
|
144
757
|
if (isSelected) {
|
|
145
758
|
return expression.kind === "Apply" ? expression.args.length : 0;
|
|
146
759
|
}
|
|
147
|
-
const
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
?
|
|
151
|
-
:
|
|
760
|
+
const spelling = (expression.kind === "Identifier" ? undefined : expression.spelling) ?? name;
|
|
761
|
+
const range = formatRange(
|
|
762
|
+
expression.kind === "Apply" && spelling === "-."
|
|
763
|
+
? getNameRange(location, "-")
|
|
764
|
+
: getSpelledNameRange(expression, name),
|
|
152
765
|
);
|
|
766
|
+
if (!isOperatorSymbol(name) || isStepName(name)) {
|
|
767
|
+
unit.errors.push({ location: range, message: `Unknown operator: \`${name}'.` });
|
|
768
|
+
return undefined;
|
|
769
|
+
}
|
|
770
|
+
unit.errors.push({
|
|
771
|
+
location: range,
|
|
772
|
+
message: `Could not find declaration or definition of symbol '${spelling}'.`,
|
|
773
|
+
});
|
|
774
|
+
const fixity = getFixity(expression);
|
|
775
|
+
if (fixity && location.range) {
|
|
776
|
+
unit.errors.push({
|
|
777
|
+
location: formatRange(location.range),
|
|
778
|
+
message: `Couldn't resolve ${fixity} operator symbol \`${spelling}'.`,
|
|
779
|
+
});
|
|
780
|
+
}
|
|
781
|
+
return undefined;
|
|
153
782
|
};
|
|
154
783
|
|
|
155
784
|
const resolveBounds = (bounds: Bound[], scope: LocalName | undefined, unit: Unit) => {
|
|
156
785
|
bounds.forEach((bound) => resolveExpression(bound.set, scope, unit));
|
|
157
786
|
return bounds.reduce(
|
|
158
|
-
(current, bound) =>
|
|
787
|
+
(current, bound) =>
|
|
788
|
+
bindNames(current, getPatternNames(bound.pattern), bound.pattern.ranges, unit),
|
|
159
789
|
scope,
|
|
160
790
|
);
|
|
161
791
|
};
|
|
@@ -171,94 +801,286 @@ const markRecursiveConstructions = (expression: Expression, name: string): void
|
|
|
171
801
|
getChildren(expression).forEach((child) => markRecursiveConstructions(child, name));
|
|
172
802
|
};
|
|
173
803
|
|
|
174
|
-
|
|
175
|
-
|
|
804
|
+
// Generator.processOperator binds the parameters, reports a name already bound unless a RECURSIVE
|
|
805
|
+
// declaration of this level awaits the definition, analyzes the body, and then binds the name.
|
|
806
|
+
// processFunction binds the bound names before it looks up the name, and binds the name only where
|
|
807
|
+
// nothing else does. recursive holds the declarations of this level. Tells whether to bind the name.
|
|
808
|
+
const resolveDefinition = (
|
|
809
|
+
definition: Definition,
|
|
810
|
+
scope: LocalName | undefined,
|
|
811
|
+
outer: Unit,
|
|
812
|
+
recursive: Set<Binding>,
|
|
813
|
+
) => {
|
|
814
|
+
const unit = {
|
|
815
|
+
...outer,
|
|
816
|
+
hasLabelScope: true,
|
|
817
|
+
labelParams: definition.kind === "Function" ? getBoundNames(definition.bounds) : [],
|
|
818
|
+
labels: new Set<string>(),
|
|
819
|
+
};
|
|
820
|
+
const name = definition.name;
|
|
821
|
+
const range = definition.location.range;
|
|
822
|
+
const report = (message: string) => {
|
|
823
|
+
if (range && !unit.isGenerated) unit.errors.push({ location: formatRange(range), message });
|
|
824
|
+
};
|
|
825
|
+
const inner =
|
|
826
|
+
definition.kind === "Function"
|
|
827
|
+
? resolveBounds(definition.bounds, scope, unit)
|
|
828
|
+
: bindParams(scope, definition.params, unit);
|
|
829
|
+
const current = lookupLocal(inner, name) ?? getModuleBinding(name, unit, range);
|
|
830
|
+
const isDeclared = current?.isPending === true && recursive.has(current);
|
|
831
|
+
if (current?.isPending && !isDeclared) {
|
|
832
|
+
report(
|
|
833
|
+
`Recursive ${definition.kind === "Function" ? "function" : "operator"} ${name} defined at wrong LET/IN level.`,
|
|
834
|
+
);
|
|
835
|
+
} else if (current && !isDeclared) {
|
|
836
|
+
report(
|
|
837
|
+
definition.kind === "Function"
|
|
838
|
+
? `Function name \`${name}' already defined or declared.`
|
|
839
|
+
: `Operator ${name} already defined or declared.`,
|
|
840
|
+
);
|
|
841
|
+
}
|
|
176
842
|
if (definition.kind === "Function") {
|
|
177
|
-
resolveExpression(
|
|
178
|
-
|
|
179
|
-
|
|
843
|
+
resolveExpression(
|
|
844
|
+
definition.body,
|
|
845
|
+
{ name, kind: "Parameter", arity: 0, range, parent: inner },
|
|
846
|
+
unit,
|
|
847
|
+
);
|
|
848
|
+
markRecursiveConstructions(definition.body, name);
|
|
849
|
+
definition.isSelfReferential = isReferenced(definition.body, name);
|
|
850
|
+
} else resolveExpression(definition.body, inner, unit);
|
|
851
|
+
if (current && isDeclared) {
|
|
852
|
+
current.isPending = false;
|
|
853
|
+
current.range = range;
|
|
854
|
+
return false;
|
|
180
855
|
}
|
|
181
|
-
|
|
856
|
+
return definition.kind === "Function"
|
|
857
|
+
? current === undefined
|
|
858
|
+
: isBindable(
|
|
859
|
+
name,
|
|
860
|
+
lookupLocal(scope, name) ?? getModuleBinding(name, unit, range),
|
|
861
|
+
{ kind: "Definition", arity: getArity(definition), range },
|
|
862
|
+
unit,
|
|
863
|
+
);
|
|
182
864
|
};
|
|
183
865
|
|
|
866
|
+
// SANY analyzes an INSTANCE in a LET where it appears, before the definitions that follow it, which
|
|
867
|
+
// tla-ts generates at its location and analyzes without reporting.
|
|
184
868
|
const resolveDefinitions = (
|
|
185
869
|
definitions: Definition[],
|
|
186
870
|
scope: LocalName | undefined,
|
|
187
871
|
unit: Unit,
|
|
872
|
+
instances: Instance[] = [],
|
|
188
873
|
) => {
|
|
189
|
-
const
|
|
874
|
+
const recursive = new Set<Binding>();
|
|
875
|
+
const declared = definitions
|
|
190
876
|
.filter((definition) => definition.isRecursive)
|
|
191
|
-
.reduce<LocalName | undefined>(
|
|
192
|
-
(parent, definition
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
877
|
+
.reduce<LocalName | undefined>((parent, definition) => {
|
|
878
|
+
if (lookupLocal(parent, definition.name)?.isPending) return parent;
|
|
879
|
+
const local: LocalName = {
|
|
880
|
+
name: definition.name,
|
|
881
|
+
arity: getArity(definition),
|
|
882
|
+
params: getParamArities(definition),
|
|
883
|
+
kind: "Definition",
|
|
884
|
+
parent,
|
|
885
|
+
isPending: true,
|
|
886
|
+
};
|
|
887
|
+
recursive.add(local);
|
|
888
|
+
return local;
|
|
889
|
+
}, scope);
|
|
890
|
+
const pending = unit.isGenerated ? [] : [...instances];
|
|
891
|
+
const resolveInstances = (
|
|
892
|
+
current: LocalName | undefined,
|
|
893
|
+
isDue: (instance: Instance) => boolean,
|
|
894
|
+
) => {
|
|
895
|
+
const count = pending.findIndex((instance) => !isDue(instance));
|
|
896
|
+
return pending
|
|
897
|
+
.splice(0, count === -1 ? pending.length : count)
|
|
898
|
+
.reduce((parent, instance) => resolveLocalInstance(instance, parent, unit), current);
|
|
899
|
+
};
|
|
900
|
+
const resolved = definitions.reduce<LocalName | undefined>((previous, definition) => {
|
|
901
|
+
const current = isKey(definition.name)
|
|
902
|
+
? previous
|
|
903
|
+
: resolveInstances(previous, (instance) => !isBefore(definition.location, instance.location));
|
|
904
|
+
const local: LocalName = {
|
|
905
|
+
name: definition.name,
|
|
906
|
+
arity: getArity(definition),
|
|
907
|
+
kind: "Definition",
|
|
908
|
+
range: definition.location.range,
|
|
909
|
+
parent: current,
|
|
910
|
+
};
|
|
911
|
+
if (isInstantiated(definition)) return local;
|
|
912
|
+
const isInstanced = instances.some((instance) => instance.location === definition.location);
|
|
913
|
+
const isGenerated = unit.isGenerated || definition.isLocal || isKey(definition.name);
|
|
914
|
+
const inner = isInstanced
|
|
915
|
+
? { ...unit, isGenerated: true, errors: [], warnings: [] }
|
|
916
|
+
: isGenerated
|
|
917
|
+
? { ...unit, isGenerated }
|
|
918
|
+
: unit;
|
|
919
|
+
return resolveDefinition(definition, current, inner, recursive)
|
|
920
|
+
? { ...local, params: getParamArities(definition) }
|
|
921
|
+
: current;
|
|
922
|
+
}, declared);
|
|
923
|
+
return resolveInstances(resolved, () => true);
|
|
199
924
|
};
|
|
200
925
|
|
|
201
|
-
//
|
|
202
|
-
|
|
203
|
-
const
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
|
|
926
|
+
// The INSTANCE that a name such as K!C starts with, whose arguments SANY requires at its name.
|
|
927
|
+
const findInstance = (name: string, scope: LocalName | undefined, unit: Unit) => {
|
|
928
|
+
const prefix = name.split("!")[0];
|
|
929
|
+
const binding =
|
|
930
|
+
prefix === name
|
|
931
|
+
? undefined
|
|
932
|
+
: (lookupLocal(scope, prefix) ?? getModuleBinding(prefix, unit, undefined));
|
|
933
|
+
return binding?.kind === "Instance" ? { name: prefix, arity: binding.arity } : undefined;
|
|
934
|
+
};
|
|
935
|
+
|
|
936
|
+
// Generator.selectorToNode reports an INSTANCE given the wrong number of arguments at its name,
|
|
937
|
+
// as in K!C or K(1, 2)!C, and goes on without analyzing them. Tells whether it reports one.
|
|
938
|
+
const isInstanceArityReported = (
|
|
939
|
+
expression: Expression,
|
|
940
|
+
scope: LocalName | undefined,
|
|
941
|
+
unit: Unit,
|
|
209
942
|
) => {
|
|
210
|
-
|
|
211
|
-
const
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
943
|
+
if (expression.kind !== "Identifier" && expression.kind !== "Apply") return false;
|
|
944
|
+
const instance = findInstance(
|
|
945
|
+
expression.kind === "Identifier" ? expression.name : expression.operator,
|
|
946
|
+
scope,
|
|
947
|
+
unit,
|
|
948
|
+
);
|
|
949
|
+
const count = expression.kind === "Apply" ? (expression.argumentCounts?.[0] ?? 0) : 0;
|
|
950
|
+
if (!instance || count === instance.arity) return false;
|
|
951
|
+
const range =
|
|
952
|
+
(expression.kind === "Apply" ? expression.argumentRanges?.[0] : undefined) ??
|
|
953
|
+
expression.location.range;
|
|
954
|
+
if (range) {
|
|
955
|
+
unit.errors.push({
|
|
956
|
+
location: formatRange(range),
|
|
957
|
+
message: `The operator ${instance.name} requires ${instance.arity} arguments.`,
|
|
958
|
+
});
|
|
223
959
|
}
|
|
960
|
+
return true;
|
|
224
961
|
};
|
|
225
962
|
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
: undefined;
|
|
232
|
-
|
|
963
|
+
// Generator.generateExprOrOpArg analyzes an argument as an expression, unless a defined operator
|
|
964
|
+
// takes an operator in its place, which a name, a built-in operator, or a LAMBDA of the parameter's
|
|
965
|
+
// arity must give. OpDefNode#match then reports each argument that gives no such operator, or one
|
|
966
|
+
// whose own parameters take operators. tla-ts lets an operator whose parameters it does not know
|
|
967
|
+
// take any argument.
|
|
233
968
|
const resolveApply = (
|
|
234
969
|
expression: Expression & { kind: "Apply" },
|
|
235
970
|
scope: LocalName | undefined,
|
|
236
971
|
unit: Unit,
|
|
237
972
|
) => {
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
const arity = getSymbolArity(expression,
|
|
973
|
+
if (isInstanceArityReported(expression, scope, unit)) return;
|
|
974
|
+
const operator = expression.operator;
|
|
975
|
+
const callee = findBinding(operator, scope, unit);
|
|
976
|
+
const arity = getSymbolArity(expression, operator, scope, unit);
|
|
977
|
+
if (arity === undefined) return;
|
|
242
978
|
if (arity !== expression.args.length) {
|
|
243
|
-
|
|
244
|
-
|
|
245
|
-
|
|
979
|
+
unit.errors.push({
|
|
980
|
+
location: formatRange(expression.argumentsRange ?? getSpelledNameRange(expression, operator)),
|
|
981
|
+
message: `The operator ${operator} requires ${arity - (findInstance(operator, scope, unit)?.arity ?? 0)} arguments.`,
|
|
982
|
+
});
|
|
983
|
+
return;
|
|
246
984
|
}
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
985
|
+
const params = callee && (callee.kind === "Definition" ? callee.params : []);
|
|
986
|
+
if (params === undefined) {
|
|
987
|
+
expression.args.forEach((arg) => resolveArgument(arg, scope, unit));
|
|
988
|
+
return;
|
|
989
|
+
}
|
|
990
|
+
const report = (range: SourceRange | undefined, message: string) => {
|
|
991
|
+
if (range) unit.errors.push({ location: formatRange(range), message });
|
|
992
|
+
};
|
|
993
|
+
expression.args
|
|
994
|
+
.map((arg, index) => {
|
|
995
|
+
const expected = params[index] ?? 0;
|
|
996
|
+
const range = arg.location.range;
|
|
997
|
+
if (expected === 0) {
|
|
998
|
+
// SANY fails on an operator here with an internal error, so tla-ts words it as it does for
|
|
999
|
+
// a name.
|
|
1000
|
+
if (arg.kind === "Lambda" && arg.operator !== undefined) {
|
|
1001
|
+
report(range, `The operator ${arg.operator} requires 1 arguments.`);
|
|
1002
|
+
} else if (arg.kind === "Lambda" && range) {
|
|
1003
|
+
report(range, "LAMBDA expression used where an expression is required.");
|
|
1004
|
+
} else if (arg.kind === "OperatorReference") {
|
|
1005
|
+
const argArity = getSymbolArity(arg, arg.operator, scope, unit);
|
|
1006
|
+
if (argArity !== undefined) {
|
|
1007
|
+
report(range, `The operator ${arg.operator} requires ${argArity} arguments.`);
|
|
1008
|
+
}
|
|
1009
|
+
} else resolveExpression(arg, scope, unit);
|
|
1010
|
+
return true;
|
|
1011
|
+
}
|
|
1012
|
+
// A name that selects a subexpression gives an operator of the names it leaves unbound.
|
|
1013
|
+
if (arg.kind === "Lambda") {
|
|
1014
|
+
resolveExpression(arg, scope, unit);
|
|
1015
|
+
const isMatched = arg.params.length === expected;
|
|
1016
|
+
if (!isMatched && selections.has(arg)) {
|
|
1017
|
+
report(
|
|
1018
|
+
range,
|
|
1019
|
+
`Expected arity ${expected} but found operator of arity ${arg.params.length}.`,
|
|
1020
|
+
);
|
|
1021
|
+
} else if (!isMatched && range && arg.operator === undefined) {
|
|
1022
|
+
report(
|
|
1023
|
+
expression.selectorRanges?.at(-1) ?? getSpelledNameRange(expression, operator),
|
|
1024
|
+
`Lambda expression with arity ${arg.params.length} used as argument ${index + 1} of operator \`${operator}', \nbut an operator of arity ${expected} is required.`,
|
|
1025
|
+
);
|
|
1026
|
+
}
|
|
1027
|
+
return isMatched;
|
|
1028
|
+
}
|
|
1029
|
+
if (arg.kind === "Subexpression") {
|
|
1030
|
+
resolveExpression(arg, scope, unit);
|
|
1031
|
+
return true;
|
|
1032
|
+
}
|
|
1033
|
+
// Generator.selectorToNode: a name such as K(1)!C names an operator, but none of its parts
|
|
1034
|
+
// may take arguments.
|
|
1035
|
+
if (arg.kind === "Apply" && arg.argumentCounts?.at(-1) === 0) {
|
|
1036
|
+
const index = arg.argumentCounts.findIndex((count) => count > 0);
|
|
1037
|
+
report(
|
|
1038
|
+
arg.selectorRanges?.[index],
|
|
1039
|
+
`Selector \`${arg.operator.split("!")[index]}' should not have argument(s).`,
|
|
1040
|
+
);
|
|
1041
|
+
return false;
|
|
1042
|
+
}
|
|
1043
|
+
if (arg.kind !== "Identifier" && arg.kind !== "OperatorReference") {
|
|
1044
|
+
report(
|
|
1045
|
+
range,
|
|
1046
|
+
`An expression appears as argument number ${index + 1} (counting from 1) to operator '${operator}', in a position an operator is required.`,
|
|
1047
|
+
);
|
|
1048
|
+
return false;
|
|
1049
|
+
}
|
|
1050
|
+
const name = arg.kind === "Identifier" ? arg.name : arg.operator;
|
|
1051
|
+
const argParams = findBinding(name, scope, unit)?.params ?? [];
|
|
1052
|
+
const argArity = getSymbolArity(arg, name, scope, unit);
|
|
1053
|
+
if (arg.kind === "Identifier" && argArity !== undefined && argArity !== expected) {
|
|
1054
|
+
report(
|
|
1055
|
+
getSpelledNameRange(arg, name),
|
|
1056
|
+
`Expected arity ${expected} but found operator of arity ${argArity}.`,
|
|
1057
|
+
);
|
|
1058
|
+
}
|
|
1059
|
+
return argArity === expected && argParams.every((param) => param === 0);
|
|
1060
|
+
})
|
|
1061
|
+
.forEach((isMatched, index) => {
|
|
1062
|
+
if (!isMatched) {
|
|
1063
|
+
report(
|
|
1064
|
+
expression.location.range,
|
|
1065
|
+
`Argument number ${index + 1} to operator '${operator}' \nshould be a ${params[index]}-parameter operator.`,
|
|
1066
|
+
);
|
|
1067
|
+
}
|
|
1068
|
+
});
|
|
254
1069
|
};
|
|
255
1070
|
|
|
256
1071
|
// An argument may name an operator that takes arguments of its own.
|
|
257
1072
|
const resolveArgument = (arg: Expression, scope: LocalName | undefined, unit: Unit) => {
|
|
258
|
-
if (arg.kind === "Identifier")
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
|
|
1073
|
+
if (arg.kind === "Identifier") getSymbolArity(arg, arg.name, scope, unit);
|
|
1074
|
+
else resolveExpression(arg, scope, unit);
|
|
1075
|
+
};
|
|
1076
|
+
|
|
1077
|
+
// Reports the error of a name that selects nothing, after the arguments SANY analyzes before it.
|
|
1078
|
+
const isSelectionReported = (expression: Expression, scope: LocalName | undefined, unit: Unit) => {
|
|
1079
|
+
const failed = selectionErrors.get(expression);
|
|
1080
|
+
if (!failed) return false;
|
|
1081
|
+
failed.args.forEach((arg) => resolveArgument(arg, scope, unit));
|
|
1082
|
+
unit.errors.push(failed.error);
|
|
1083
|
+
return true;
|
|
262
1084
|
};
|
|
263
1085
|
|
|
264
1086
|
const resolveExpression = (
|
|
@@ -266,8 +1088,16 @@ const resolveExpression = (
|
|
|
266
1088
|
scope: LocalName | undefined,
|
|
267
1089
|
unit: Unit,
|
|
268
1090
|
): void => {
|
|
1091
|
+
if (selections.has(expression) && !unit.isGenerated) {
|
|
1092
|
+
resolveExpression(expression, scope, { ...unit, isGenerated: true });
|
|
1093
|
+
return;
|
|
1094
|
+
}
|
|
269
1095
|
const resolveAll = (expressions: Expression[]) =>
|
|
270
1096
|
expressions.forEach((child) => resolveExpression(child, scope, unit));
|
|
1097
|
+
const bindLabelParams = (names: string[]) => ({
|
|
1098
|
+
...unit,
|
|
1099
|
+
labelParams: [...unit.labelParams, ...names],
|
|
1100
|
+
});
|
|
271
1101
|
switch (expression.kind) {
|
|
272
1102
|
case "Number":
|
|
273
1103
|
case "Decimal":
|
|
@@ -275,11 +1105,14 @@ const resolveExpression = (
|
|
|
275
1105
|
case "ExceptAt":
|
|
276
1106
|
return;
|
|
277
1107
|
case "Identifier": {
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
|
|
282
|
-
|
|
1108
|
+
if (isInstanceArityReported(expression, scope, unit)) return;
|
|
1109
|
+
const name = expression.name;
|
|
1110
|
+
const arity = getSymbolArity(expression, name, scope, unit);
|
|
1111
|
+
if (arity !== undefined && arity > 0) {
|
|
1112
|
+
unit.errors.push({
|
|
1113
|
+
location: formatRange(getSpelledNameRange(expression, name)),
|
|
1114
|
+
message: `The operator ${name} requires ${arity} arguments.`,
|
|
1115
|
+
});
|
|
283
1116
|
}
|
|
284
1117
|
return;
|
|
285
1118
|
}
|
|
@@ -290,7 +1123,11 @@ const resolveExpression = (
|
|
|
290
1123
|
resolveApply(expression, scope, unit);
|
|
291
1124
|
return;
|
|
292
1125
|
case "Lambda":
|
|
293
|
-
resolveExpression(
|
|
1126
|
+
resolveExpression(
|
|
1127
|
+
expression.body,
|
|
1128
|
+
bindNames(scope, expression.params, expression.paramRanges, unit),
|
|
1129
|
+
bindLabelParams(expression.params),
|
|
1130
|
+
);
|
|
294
1131
|
return;
|
|
295
1132
|
case "And":
|
|
296
1133
|
case "Or":
|
|
@@ -313,24 +1150,32 @@ const resolveExpression = (
|
|
|
313
1150
|
case "Let":
|
|
314
1151
|
resolveExpression(
|
|
315
1152
|
expression.body,
|
|
316
|
-
resolveDefinitions(expression.definitions, scope, unit),
|
|
1153
|
+
resolveDefinitions(expression.definitions, scope, unit, expression.instances),
|
|
317
1154
|
unit,
|
|
318
1155
|
);
|
|
319
1156
|
return;
|
|
320
1157
|
case "Forall":
|
|
321
1158
|
case "Exists":
|
|
322
1159
|
case "FunctionConstruction":
|
|
323
|
-
resolveExpression(
|
|
1160
|
+
resolveExpression(
|
|
1161
|
+
expression.body,
|
|
1162
|
+
resolveBounds(expression.bounds, scope, unit),
|
|
1163
|
+
bindLabelParams(getBoundNames(expression.bounds)),
|
|
1164
|
+
);
|
|
324
1165
|
return;
|
|
325
1166
|
case "UnboundedQuantifier":
|
|
326
|
-
resolveExpression(
|
|
1167
|
+
resolveExpression(
|
|
1168
|
+
expression.body,
|
|
1169
|
+
bindNames(scope, expression.names, expression.nameRanges, unit),
|
|
1170
|
+
bindLabelParams(expression.names),
|
|
1171
|
+
);
|
|
327
1172
|
return;
|
|
328
1173
|
case "Choose":
|
|
329
1174
|
if (expression.set) resolveExpression(expression.set, scope, unit);
|
|
330
1175
|
resolveExpression(
|
|
331
1176
|
expression.body,
|
|
332
|
-
bindNames(scope, getPatternNames(expression.pattern)),
|
|
333
|
-
|
|
1177
|
+
bindNames(scope, getPatternNames(expression.pattern), expression.pattern.ranges, unit),
|
|
1178
|
+
bindLabelParams(getPatternNames(expression.pattern)),
|
|
334
1179
|
);
|
|
335
1180
|
return;
|
|
336
1181
|
case "SetEnumeration":
|
|
@@ -338,31 +1183,40 @@ const resolveExpression = (
|
|
|
338
1183
|
resolveAll(expression.elements);
|
|
339
1184
|
return;
|
|
340
1185
|
case "SetFilter":
|
|
341
|
-
resolveExpression(
|
|
1186
|
+
resolveExpression(
|
|
1187
|
+
expression.predicate,
|
|
1188
|
+
resolveBounds([expression.bound], scope, unit),
|
|
1189
|
+
bindLabelParams(getPatternNames(expression.bound.pattern)),
|
|
1190
|
+
);
|
|
342
1191
|
return;
|
|
343
1192
|
case "SetMap":
|
|
344
|
-
resolveExpression(
|
|
1193
|
+
resolveExpression(
|
|
1194
|
+
expression.expression,
|
|
1195
|
+
resolveBounds(expression.bounds, scope, unit),
|
|
1196
|
+
bindLabelParams(getBoundNames(expression.bounds)),
|
|
1197
|
+
);
|
|
345
1198
|
return;
|
|
346
1199
|
case "FunctionSet":
|
|
347
1200
|
resolveAll([expression.domain, expression.range]);
|
|
348
1201
|
return;
|
|
349
1202
|
case "Record":
|
|
350
1203
|
case "RecordSet":
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
|
|
1204
|
+
expression.fields.forEach((field, index) => {
|
|
1205
|
+
if (expression.fields.slice(0, index).some((earlier) => earlier.name === field.name)) {
|
|
1206
|
+
unit.errors.push({
|
|
1207
|
+
location: formatRange(field.location.range ?? getNameRange(field.location, field.name)),
|
|
1208
|
+
message: "Non-unique fields in constructor.",
|
|
1209
|
+
});
|
|
1210
|
+
}
|
|
1211
|
+
resolveExpression(field.value, scope, unit);
|
|
1212
|
+
});
|
|
357
1213
|
return;
|
|
358
1214
|
case "Except":
|
|
359
|
-
|
|
360
|
-
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
]),
|
|
365
|
-
]);
|
|
1215
|
+
resolveExpression(expression.function, scope, unit);
|
|
1216
|
+
expression.updates.forEach((update) => {
|
|
1217
|
+
resolveAll(update.path.flatMap((step) => (step.kind === "Index" ? step.args : [])));
|
|
1218
|
+
resolveExpression(update.value, scope, { ...unit, isInExcept: true });
|
|
1219
|
+
});
|
|
366
1220
|
return;
|
|
367
1221
|
case "FunctionApplication":
|
|
368
1222
|
resolveAll([expression.function, ...expression.args]);
|
|
@@ -382,34 +1236,77 @@ const resolveExpression = (
|
|
|
382
1236
|
resolveAll([expression.subscript, expression.action]);
|
|
383
1237
|
return;
|
|
384
1238
|
case "Label":
|
|
385
|
-
|
|
1239
|
+
if (isLabelReported(expression, unit)) return;
|
|
1240
|
+
resolveExpression(expression.body, scope, { ...unit, labelParams: [], labels: new Set() });
|
|
1241
|
+
checkLabel(expression, scope, unit);
|
|
386
1242
|
return;
|
|
387
|
-
case "Subexpression":
|
|
1243
|
+
case "Subexpression": {
|
|
1244
|
+
if (isSelectionReported(expression, scope, unit)) return;
|
|
388
1245
|
expression.selectors
|
|
389
1246
|
.flatMap((selector) => ("args" in selector ? selector.args : []))
|
|
390
1247
|
.forEach((arg) => resolveArgument(arg, scope, unit));
|
|
1248
|
+
checkReference(expression, scope, unit, false);
|
|
1249
|
+
}
|
|
391
1250
|
}
|
|
392
1251
|
};
|
|
393
1252
|
|
|
1253
|
+
// Generator.generateUseOrHide looks up a fact that is a name as it looks up a name in an expression,
|
|
1254
|
+
// except that the name may select an ASSUME/PROVE or a NEW clause or name a theorem or assumption,
|
|
1255
|
+
// and analyzes any other fact as an expression.
|
|
1256
|
+
const checkFacts = (facts: Fact[], scope: LocalName | undefined, unit: Unit) =>
|
|
1257
|
+
facts.forEach((fact) => {
|
|
1258
|
+
if (
|
|
1259
|
+
fact.kind === "ModuleFact" ||
|
|
1260
|
+
isInstanceArityReported(fact, scope, unit) ||
|
|
1261
|
+
checkReference(fact, scope, unit, true)
|
|
1262
|
+
) {
|
|
1263
|
+
return;
|
|
1264
|
+
}
|
|
1265
|
+
const name =
|
|
1266
|
+
fact.kind === "Identifier" ? fact.name : fact.kind === "Apply" ? fact.operator : "";
|
|
1267
|
+
if (fact.kind === "Identifier" && lookupLocal(scope, name)?.isNonFact) {
|
|
1268
|
+
unit.errors.push({
|
|
1269
|
+
location: formatRange(getSpelledNameRange(fact, name)),
|
|
1270
|
+
message: "Step number of non-fact used as a fact",
|
|
1271
|
+
});
|
|
1272
|
+
} else if (!unit.facts.has(name)) resolveExpression(fact, scope, unit);
|
|
1273
|
+
});
|
|
1274
|
+
|
|
394
1275
|
const resolveNewSymbol = (symbol: NewSymbol, scope: LocalName | undefined, unit: Unit) => {
|
|
395
1276
|
if (symbol.set) resolveExpression(symbol.set, scope, unit);
|
|
396
|
-
return
|
|
1277
|
+
return bindName(
|
|
1278
|
+
scope,
|
|
1279
|
+
symbol.name,
|
|
1280
|
+
{ kind: `New${symbol.level}`, arity: symbol.arity, range: symbol.nameRange },
|
|
1281
|
+
unit,
|
|
1282
|
+
);
|
|
397
1283
|
};
|
|
398
1284
|
|
|
399
|
-
// The NEW symbols of an ASSUME stay in scope for its conclusion and the proof that follows.
|
|
1285
|
+
// The NEW symbols of an ASSUME stay in scope for its conclusion and the proof that follows. SANY
|
|
1286
|
+
// forbids a label in the scope of a NEW in a nested ASSUME.
|
|
400
1287
|
const resolveAssumeProve = (
|
|
401
1288
|
assumeProve: AssumeProve,
|
|
402
1289
|
scope: LocalName | undefined,
|
|
403
1290
|
unit: Unit,
|
|
1291
|
+
isNested = false,
|
|
404
1292
|
): LocalName | undefined => {
|
|
405
|
-
const assumed = assumeProve.assumptions.reduce(
|
|
406
|
-
|
|
407
|
-
|
|
408
|
-
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
|
|
1293
|
+
const assumed = assumeProve.assumptions.reduce(
|
|
1294
|
+
(current, assumption) => {
|
|
1295
|
+
if (assumption.kind === "NewSymbol") {
|
|
1296
|
+
return {
|
|
1297
|
+
scope: resolveNewSymbol(assumption, current.scope, current.unit),
|
|
1298
|
+
unit: isNested ? { ...current.unit, isLabelForbidden: true } : current.unit,
|
|
1299
|
+
};
|
|
1300
|
+
}
|
|
1301
|
+
if (assumption.kind === "AssumeProve") {
|
|
1302
|
+
resolveAssumeProve(assumption, current.scope, current.unit, true);
|
|
1303
|
+
} else resolveExpression(assumption, current.scope, current.unit);
|
|
1304
|
+
return current;
|
|
1305
|
+
},
|
|
1306
|
+
{ scope, unit },
|
|
1307
|
+
);
|
|
1308
|
+
resolveExpression(assumeProve.conclusion, assumed.scope, assumed.unit);
|
|
1309
|
+
return assumed.scope;
|
|
413
1310
|
};
|
|
414
1311
|
|
|
415
1312
|
const resolveStatement = (
|
|
@@ -424,371 +1321,528 @@ const resolveStatement = (
|
|
|
424
1321
|
|
|
425
1322
|
// SANY resolves the expressions of a proof, while its facts and DEF clauses may also name
|
|
426
1323
|
// theorems, assumptions, and modules.
|
|
427
|
-
const resolveProof = (proof: Proof | undefined, scope: LocalName | undefined,
|
|
1324
|
+
const resolveProof = (proof: Proof | undefined, scope: LocalName | undefined, outer: Unit) => {
|
|
1325
|
+
const unit = outer.hasLabelScope ? { ...outer, hasLabelScope: false } : outer;
|
|
1326
|
+
if (proof?.kind === "By") checkFacts(proof.facts, scope, unit);
|
|
428
1327
|
if (proof?.kind !== "Steps") return;
|
|
429
1328
|
proof.steps.reduce((current, step) => resolveStep(step, current, unit), scope);
|
|
430
1329
|
};
|
|
431
1330
|
|
|
1331
|
+
// A LET or a step binds the name of the INSTANCE after the names it adds.
|
|
1332
|
+
const resolveLocalInstance = (instance: Instance, scope: LocalName | undefined, unit: Unit) => {
|
|
1333
|
+
const instanced = resolveInstance(instance, scope, unit);
|
|
1334
|
+
return instance.name === undefined
|
|
1335
|
+
? instanced
|
|
1336
|
+
: bindName(
|
|
1337
|
+
instanced,
|
|
1338
|
+
instance.name,
|
|
1339
|
+
{ kind: "Instance", arity: instance.params.length, range: instance.location.range },
|
|
1340
|
+
unit,
|
|
1341
|
+
);
|
|
1342
|
+
};
|
|
1343
|
+
|
|
1344
|
+
// Generator.generateProof binds the name of a step after its statement and before its proof, or
|
|
1345
|
+
// after the step where it takes no proof.
|
|
432
1346
|
const resolveStep = (
|
|
433
1347
|
step: ProofStep,
|
|
434
1348
|
scope: LocalName | undefined,
|
|
435
1349
|
unit: Unit,
|
|
436
1350
|
): LocalName | undefined => {
|
|
437
1351
|
const body = step.body;
|
|
1352
|
+
const stepUnit =
|
|
1353
|
+
step.name === undefined
|
|
1354
|
+
? unit
|
|
1355
|
+
: { ...unit, hasLabelScope: true, labelParams: [], labels: new Set<string>() };
|
|
1356
|
+
const bindStep = (parent: LocalName | undefined): LocalName | undefined =>
|
|
1357
|
+
step.name === undefined ? parent : { name: step.name, arity: 0, kind: "Theorem", parent };
|
|
1358
|
+
const bindNonFactStep = (parent: LocalName | undefined): LocalName | undefined =>
|
|
1359
|
+
step.name === undefined
|
|
1360
|
+
? parent
|
|
1361
|
+
: { name: step.name, arity: 0, kind: "Theorem", parent, isNonFact: true };
|
|
438
1362
|
switch (body.kind) {
|
|
1363
|
+
// The NEW symbols of a SUFFICES ASSUME are in scope after its proof, and those of any other
|
|
1364
|
+
// ASSUME in its proof.
|
|
439
1365
|
case "Assert": {
|
|
440
|
-
const assumed = resolveStatement(body.statement, scope,
|
|
441
|
-
|
|
442
|
-
|
|
1366
|
+
const assumed = resolveStatement(body.statement, scope, stepUnit);
|
|
1367
|
+
const proofScope = body.isSuffices ? scope : assumed;
|
|
1368
|
+
const name = step.name;
|
|
1369
|
+
if (name === undefined) {
|
|
1370
|
+
resolveProof(step.proof, proofScope, unit);
|
|
1371
|
+
return body.isSuffices ? assumed : scope;
|
|
1372
|
+
}
|
|
1373
|
+
const goal = { statement: body.statement, isSuffices: body.isSuffices, isInProof: true };
|
|
1374
|
+
resolveProof(step.proof, { name, arity: 0, kind: "Theorem", parent: proofScope, goal }, unit);
|
|
1375
|
+
goal.isInProof = false;
|
|
1376
|
+
return { name, arity: 0, kind: "Theorem", parent: body.isSuffices ? assumed : scope, goal };
|
|
443
1377
|
}
|
|
1378
|
+
case "Use":
|
|
1379
|
+
case "Hide":
|
|
1380
|
+
checkFacts(body.facts, scope, unit);
|
|
1381
|
+
return bindNonFactStep(scope);
|
|
1382
|
+
case "Instance":
|
|
1383
|
+
return bindNonFactStep(resolveLocalInstance(body, scope, stepUnit));
|
|
444
1384
|
case "Define":
|
|
445
|
-
return
|
|
446
|
-
body.definitions.
|
|
447
|
-
definition
|
|
1385
|
+
return bindNonFactStep(
|
|
1386
|
+
body.definitions.reduce(
|
|
1387
|
+
(current, definition) =>
|
|
1388
|
+
definition.kind === "Instance"
|
|
1389
|
+
? resolveLocalInstance(definition, current, stepUnit)
|
|
1390
|
+
: resolveDefinitions([definition], current, unit),
|
|
1391
|
+
scope,
|
|
448
1392
|
),
|
|
449
|
-
scope,
|
|
450
|
-
unit,
|
|
451
1393
|
);
|
|
452
1394
|
case "Have":
|
|
453
1395
|
case "Case":
|
|
454
|
-
resolveExpression(body.expression, scope,
|
|
455
|
-
resolveProof(step.proof, scope, unit);
|
|
456
|
-
return scope;
|
|
1396
|
+
resolveExpression(body.expression, scope, stepUnit);
|
|
1397
|
+
resolveProof(step.proof, bindStep(scope), unit);
|
|
1398
|
+
return bindStep(scope);
|
|
457
1399
|
case "Witness":
|
|
458
|
-
body.expressions.forEach((expression) => resolveExpression(expression, scope,
|
|
459
|
-
return scope;
|
|
1400
|
+
body.expressions.forEach((expression) => resolveExpression(expression, scope, stepUnit));
|
|
1401
|
+
return bindStep(scope);
|
|
460
1402
|
case "Take":
|
|
461
|
-
return
|
|
1403
|
+
return bindStep(
|
|
1404
|
+
bindNames(
|
|
1405
|
+
resolveBounds(body.bounds, scope, stepUnit),
|
|
1406
|
+
body.names,
|
|
1407
|
+
body.nameRanges,
|
|
1408
|
+
stepUnit,
|
|
1409
|
+
),
|
|
1410
|
+
);
|
|
462
1411
|
case "Pick": {
|
|
463
|
-
const picked = bindNames(
|
|
464
|
-
|
|
465
|
-
|
|
466
|
-
|
|
1412
|
+
const picked = bindNames(
|
|
1413
|
+
resolveBounds(body.bounds, scope, stepUnit),
|
|
1414
|
+
body.names,
|
|
1415
|
+
body.nameRanges,
|
|
1416
|
+
stepUnit,
|
|
1417
|
+
);
|
|
1418
|
+
resolveExpression(body.body, picked, {
|
|
1419
|
+
...stepUnit,
|
|
1420
|
+
labelParams: [...stepUnit.labelParams, ...getBoundNames(body.bounds), ...body.names],
|
|
1421
|
+
});
|
|
1422
|
+
resolveProof(step.proof, bindStep(scope), unit);
|
|
1423
|
+
return bindStep(picked);
|
|
467
1424
|
}
|
|
468
1425
|
default:
|
|
469
|
-
resolveProof(step.proof, scope, unit);
|
|
470
|
-
return scope;
|
|
1426
|
+
resolveProof(step.proof, bindStep(scope), unit);
|
|
1427
|
+
return bindStep(scope);
|
|
471
1428
|
}
|
|
472
1429
|
};
|
|
473
1430
|
|
|
1431
|
+
// SANY binds the name of a theorem after its statement and before its proof.
|
|
474
1432
|
const resolveTheorem = (theorem: Theorem, unit: Unit) => {
|
|
475
1433
|
const isDefinition = theorem.name !== undefined && theorem.statement.kind !== "AssumeProve";
|
|
476
1434
|
const scope = isDefinition ? undefined : resolveStatement(theorem.statement, undefined, unit);
|
|
1435
|
+
if (theorem.name !== undefined) {
|
|
1436
|
+
bindModuleName(
|
|
1437
|
+
theorem.name,
|
|
1438
|
+
{ kind: "Theorem", arity: 0, range: theorem.location.range },
|
|
1439
|
+
unit,
|
|
1440
|
+
);
|
|
1441
|
+
}
|
|
1442
|
+
const goal = unit.goals.get(theorem.name ?? "");
|
|
1443
|
+
if (goal) goal.isInProof = true;
|
|
477
1444
|
resolveProof(theorem.proof, scope, unit);
|
|
1445
|
+
if (goal) goal.isInProof = false;
|
|
478
1446
|
};
|
|
479
1447
|
|
|
480
|
-
|
|
481
|
-
|
|
482
|
-
|
|
483
|
-
|
|
484
|
-
|
|
1448
|
+
// The declarations of the module an INSTANCE instantiates, the names the INSTANCE adds, and the
|
|
1449
|
+
// module that instantiates it.
|
|
1450
|
+
export interface InstancedModule {
|
|
1451
|
+
declarations: Declaration[];
|
|
1452
|
+
symbols: Symbols;
|
|
1453
|
+
instancer: string;
|
|
485
1454
|
}
|
|
486
1455
|
|
|
487
|
-
|
|
488
|
-
|
|
489
|
-
|
|
1456
|
+
// What SANY reports at a location as it links a module, such as a conflict between the modules it
|
|
1457
|
+
// extends.
|
|
1458
|
+
export interface ModuleReport {
|
|
490
1459
|
location: SourceLocation;
|
|
491
|
-
|
|
1460
|
+
errors: SanyError[];
|
|
1461
|
+
warnings: SanyError[];
|
|
1462
|
+
}
|
|
1463
|
+
|
|
1464
|
+
// bound holds the names in scope where the module starts: the built-in operators, the names of the
|
|
1465
|
+
// module that encloses it, and those of the modules it extends. instanced holds the names each
|
|
1466
|
+
// INSTANCE adds, getInstance what an INSTANCE in a LET or a proof instantiates, facts the theorems
|
|
1467
|
+
// and assumptions the modules it extends or instantiates export, and warnings the warnings SANY
|
|
1468
|
+
// reports for the spec.
|
|
1469
|
+
export interface ModuleUnit {
|
|
1470
|
+
imported: Symbols;
|
|
1471
|
+
getInstance: (instance: Instance) => InstancedModule;
|
|
1472
|
+
bound: Symbols;
|
|
1473
|
+
definitions: Map<string, Definition>;
|
|
1474
|
+
getKey: (definition: Definition) => string;
|
|
1475
|
+
instanced: Map<Instance, Symbols>;
|
|
1476
|
+
facts: Set<string>;
|
|
1477
|
+
reports: ModuleReport[];
|
|
1478
|
+
warnings: SanyError[];
|
|
492
1479
|
}
|
|
493
1480
|
|
|
494
|
-
|
|
1481
|
+
export const MODULE_START: SourceLocation = { line: 0, column: 0 };
|
|
495
1482
|
|
|
496
|
-
|
|
497
|
-
|
|
498
|
-
|
|
1483
|
+
// A named theorem or assumption is linked as a definition too.
|
|
1484
|
+
export const isTheoremDefinition = (module: Module, definition: Definition) =>
|
|
1485
|
+
[...module.theorems, ...module.assumptions].some(
|
|
1486
|
+
(item) =>
|
|
1487
|
+
item.name === definition.name &&
|
|
1488
|
+
item.location.line === definition.location.line &&
|
|
1489
|
+
item.location.column === definition.location.column,
|
|
499
1490
|
);
|
|
500
1491
|
|
|
501
|
-
const
|
|
502
|
-
|
|
503
|
-
|
|
504
|
-
|
|
505
|
-
|
|
506
|
-
) =>
|
|
507
|
-
|
|
508
|
-
if (lookupLocal(parent, name) || isDefined(name)) throw createRedefinitionError(name, location);
|
|
509
|
-
return { name, arity: 0, parent };
|
|
510
|
-
}, scope);
|
|
511
|
-
|
|
512
|
-
const checkBoundNames = (
|
|
513
|
-
bounds: Bound[],
|
|
514
|
-
scope: LocalName | undefined,
|
|
515
|
-
isDefined: IsDefined,
|
|
516
|
-
location: SourceLocation,
|
|
517
|
-
) => {
|
|
518
|
-
bounds.forEach((bound) => checkNames(bound.set, scope, isDefined));
|
|
519
|
-
return bounds.reduce(
|
|
520
|
-
(current, bound) => bindUnique(current, getPatternNames(bound.pattern), isDefined, location),
|
|
521
|
-
scope,
|
|
1492
|
+
const createSymbols = (module: Module, imported: Symbols) => {
|
|
1493
|
+
const symbols = new Map([...CORE_SYMBOLS, ...imported]);
|
|
1494
|
+
module.constants.forEach((constant) =>
|
|
1495
|
+
symbols.set(constant.name, { key: constant.name, arity: constant.arity, kind: "Constant" }),
|
|
1496
|
+
);
|
|
1497
|
+
module.variables.forEach((variable) =>
|
|
1498
|
+
symbols.set(variable.name, { key: variable.name, arity: 0, kind: "Variable" }),
|
|
522
1499
|
);
|
|
1500
|
+
return symbols;
|
|
523
1501
|
};
|
|
524
1502
|
|
|
525
|
-
|
|
526
|
-
|
|
527
|
-
|
|
528
|
-
|
|
1503
|
+
// Generator.processSubst analyzes the explicit substitutions in the order they appear, then the
|
|
1504
|
+
// implicit ones, and then reports each declaration left without one. The parameters of the INSTANCE
|
|
1505
|
+
// are in scope.
|
|
1506
|
+
const checkSubstitutions = (
|
|
1507
|
+
instance: Instance,
|
|
1508
|
+
declarations: Declaration[],
|
|
1509
|
+
instancer: string,
|
|
1510
|
+
outer: LocalName | undefined,
|
|
1511
|
+
unit: Unit,
|
|
529
1512
|
) => {
|
|
530
|
-
|
|
531
|
-
|
|
532
|
-
|
|
533
|
-
checkNames(definition.body, bound, isDefined);
|
|
534
|
-
return;
|
|
535
|
-
}
|
|
536
|
-
const params = bindUnique(
|
|
537
|
-
scope,
|
|
538
|
-
definition.params.map((param) => param.name),
|
|
539
|
-
isDefined,
|
|
540
|
-
definition.location,
|
|
1513
|
+
const scope = instance.params.reduce<LocalName | undefined>(
|
|
1514
|
+
(parent, param) => ({ name: param.name, arity: param.arity, kind: "Parameter", parent }),
|
|
1515
|
+
outer,
|
|
541
1516
|
);
|
|
542
|
-
|
|
543
|
-
|
|
544
|
-
|
|
545
|
-
const checkNames = (
|
|
546
|
-
expression: Expression,
|
|
547
|
-
scope: LocalName | undefined,
|
|
548
|
-
isDefined: IsDefined,
|
|
549
|
-
): void => {
|
|
550
|
-
const location = expression.location;
|
|
551
|
-
switch (expression.kind) {
|
|
552
|
-
case "Lambda":
|
|
553
|
-
checkNames(
|
|
554
|
-
expression.body,
|
|
555
|
-
bindUnique(scope, expression.params, isDefined, location),
|
|
556
|
-
isDefined,
|
|
557
|
-
);
|
|
558
|
-
return;
|
|
559
|
-
case "Let": {
|
|
560
|
-
const recursive = expression.definitions
|
|
561
|
-
.filter((definition) => definition.isRecursive)
|
|
562
|
-
.map((definition) => definition.name);
|
|
563
|
-
const inner = expression.definitions.reduce((current, definition) => {
|
|
564
|
-
if (lookupLocal(current, definition.name) || isDefined(definition.name)) {
|
|
565
|
-
throw createRedefinitionError(definition.name, definition.location);
|
|
566
|
-
}
|
|
567
|
-
checkDefinitionNames(definition, bindNames(current, recursive), isDefined);
|
|
568
|
-
return bindNames(current, [definition.name]);
|
|
569
|
-
}, scope);
|
|
570
|
-
checkNames(
|
|
571
|
-
expression.body,
|
|
572
|
-
bindUnique(
|
|
573
|
-
inner,
|
|
574
|
-
(expression.instances ?? []).flatMap((instance) =>
|
|
575
|
-
instance.name === undefined ? [] : [instance.name],
|
|
576
|
-
),
|
|
577
|
-
isDefined,
|
|
578
|
-
location,
|
|
579
|
-
),
|
|
580
|
-
isDefined,
|
|
581
|
-
);
|
|
1517
|
+
const resolveSubstitute = (declaration: Declaration, expression: Expression) => {
|
|
1518
|
+
if (declaration.arity === 0 || expression.kind !== "Identifier") {
|
|
1519
|
+
resolveExpression(expression, scope, unit);
|
|
582
1520
|
return;
|
|
583
1521
|
}
|
|
584
|
-
|
|
585
|
-
|
|
586
|
-
|
|
587
|
-
|
|
588
|
-
expression.body,
|
|
589
|
-
checkBoundNames(expression.bounds, scope, isDefined, location),
|
|
590
|
-
isDefined,
|
|
591
|
-
);
|
|
592
|
-
return;
|
|
593
|
-
case "SetFilter":
|
|
594
|
-
checkNames(
|
|
595
|
-
expression.predicate,
|
|
596
|
-
checkBoundNames([expression.bound], scope, isDefined, location),
|
|
597
|
-
isDefined,
|
|
598
|
-
);
|
|
599
|
-
return;
|
|
600
|
-
case "SetMap":
|
|
601
|
-
checkNames(
|
|
602
|
-
expression.expression,
|
|
603
|
-
checkBoundNames(expression.bounds, scope, isDefined, location),
|
|
604
|
-
isDefined,
|
|
605
|
-
);
|
|
606
|
-
return;
|
|
607
|
-
case "UnboundedQuantifier":
|
|
608
|
-
checkNames(
|
|
609
|
-
expression.body,
|
|
610
|
-
bindUnique(scope, expression.names, isDefined, location),
|
|
611
|
-
isDefined,
|
|
612
|
-
);
|
|
613
|
-
return;
|
|
614
|
-
case "Choose":
|
|
615
|
-
if (expression.set) checkNames(expression.set, scope, isDefined);
|
|
616
|
-
checkNames(
|
|
617
|
-
expression.body,
|
|
618
|
-
bindUnique(scope, getPatternNames(expression.pattern), isDefined, location),
|
|
619
|
-
isDefined,
|
|
1522
|
+
const arity = getSymbolArity(expression, expression.name, scope, unit);
|
|
1523
|
+
if (arity !== undefined && arity !== declaration.arity) {
|
|
1524
|
+
throw new TlaSyntaxError(
|
|
1525
|
+
`An operator must be substituted for symbol '${declaration.name}', and it must have arity ${declaration.arity} in the instance of ${instance.module} at line ${instance.location.line}, column ${instance.location.column}`,
|
|
620
1526
|
);
|
|
621
|
-
|
|
622
|
-
default:
|
|
623
|
-
getChildren(expression).forEach((child) => checkNames(child, scope, isDefined));
|
|
624
|
-
}
|
|
625
|
-
};
|
|
626
|
-
|
|
627
|
-
const getModuleNames = (module: Module) => [
|
|
628
|
-
...module.definitions.map((definition): ModuleName => ({
|
|
629
|
-
name: definition.name,
|
|
630
|
-
kind: "Definition",
|
|
631
|
-
location: definition.location,
|
|
632
|
-
isRecursive: definition.isRecursive,
|
|
633
|
-
})),
|
|
634
|
-
...module.instances.flatMap((instance): ModuleName[] =>
|
|
635
|
-
instance.name === undefined
|
|
636
|
-
? []
|
|
637
|
-
: [
|
|
638
|
-
{
|
|
639
|
-
name: instance.name,
|
|
640
|
-
kind: "Definition",
|
|
641
|
-
location: instance.location,
|
|
642
|
-
isRecursive: false,
|
|
643
|
-
},
|
|
644
|
-
],
|
|
645
|
-
),
|
|
646
|
-
...module.constants.map((constant): ModuleName => ({
|
|
647
|
-
name: constant.name,
|
|
648
|
-
kind: "Constant",
|
|
649
|
-
location: constant.location,
|
|
650
|
-
isRecursive: false,
|
|
651
|
-
})),
|
|
652
|
-
...module.variables.map((variable): ModuleName => ({
|
|
653
|
-
name: variable.name,
|
|
654
|
-
kind: "Variable",
|
|
655
|
-
location: variable.location,
|
|
656
|
-
isRecursive: false,
|
|
657
|
-
})),
|
|
658
|
-
];
|
|
659
|
-
|
|
660
|
-
export const checkRedefinitions = (module: Module, unit: ModuleUnit) => {
|
|
661
|
-
const byName = new Map<string, ModuleName[]>();
|
|
662
|
-
getModuleNames(module)
|
|
663
|
-
.sort((left, right) => (isBefore(left.location, right.location) ? -1 : 1))
|
|
664
|
-
.forEach((entry) => byName.set(entry.name, [...(byName.get(entry.name) ?? []), entry]));
|
|
665
|
-
const isImportedBefore = (name: string, location: SourceLocation) => {
|
|
666
|
-
if (!unit.imported.has(name) && !CORE_SYMBOLS.has(name)) return false;
|
|
667
|
-
const importedAt = unit.importedAt.get(name);
|
|
668
|
-
return importedAt === undefined || isBefore(importedAt, location);
|
|
1527
|
+
}
|
|
669
1528
|
};
|
|
670
|
-
|
|
671
|
-
|
|
672
|
-
|
|
673
|
-
|
|
674
|
-
|
|
675
|
-
|
|
676
|
-
|
|
677
|
-
|
|
678
|
-
|
|
679
|
-
|
|
680
|
-
|
|
681
|
-
|
|
682
|
-
|
|
683
|
-
|
|
684
|
-
|
|
685
|
-
|
|
686
|
-
|
|
687
|
-
|
|
688
|
-
|
|
689
|
-
|
|
690
|
-
|
|
691
|
-
|
|
692
|
-
|
|
693
|
-
|
|
694
|
-
|
|
695
|
-
|
|
696
|
-
|
|
697
|
-
|
|
698
|
-
|
|
699
|
-
|
|
700
|
-
|
|
701
|
-
|
|
702
|
-
|
|
703
|
-
|
|
704
|
-
|
|
705
|
-
);
|
|
706
|
-
|
|
707
|
-
|
|
708
|
-
|
|
1529
|
+
const substitutions = new Map<string, Expression>();
|
|
1530
|
+
instance.substitutions.forEach((substitution) => {
|
|
1531
|
+
const name = substitution.name;
|
|
1532
|
+
const declaration = declarations.find((item) => item.name === name);
|
|
1533
|
+
if (!declaration) {
|
|
1534
|
+
unit.errors.push({
|
|
1535
|
+
location: formatRange(substitution.nameRange),
|
|
1536
|
+
message: `Identifier '${name}' is not a legal target of a substitution. \nA legal target must be a declared CONSTANT or VARIABLE in the module being instantiated. \n(Also, check for warnings about multiple declarations of this same identifier.)`,
|
|
1537
|
+
});
|
|
1538
|
+
return;
|
|
1539
|
+
}
|
|
1540
|
+
const expression = substitution.expression;
|
|
1541
|
+
resolveSubstitute(declaration, expression);
|
|
1542
|
+
const range = expression.location.range;
|
|
1543
|
+
if (!substitutions.has(name)) substitutions.set(name, expression);
|
|
1544
|
+
else if (range) {
|
|
1545
|
+
unit.errors.push({
|
|
1546
|
+
location: formatRange(range),
|
|
1547
|
+
message: `Multiple substitutions for symbol '${name}' in substitution.`,
|
|
1548
|
+
});
|
|
1549
|
+
}
|
|
1550
|
+
});
|
|
1551
|
+
const implicit = declarations.filter((declaration) => !substitutions.has(declaration.name));
|
|
1552
|
+
const isMissing = (declaration: Declaration) =>
|
|
1553
|
+
!lookupLocal(scope, declaration.name) && !findSymbol(declaration.name, unit);
|
|
1554
|
+
implicit
|
|
1555
|
+
.filter((declaration) => !isMissing(declaration))
|
|
1556
|
+
.forEach((declaration) => {
|
|
1557
|
+
const expression: Expression = {
|
|
1558
|
+
kind: "Identifier",
|
|
1559
|
+
name: declaration.name,
|
|
1560
|
+
location: instance.location,
|
|
1561
|
+
};
|
|
1562
|
+
resolveSubstitute(declaration, expression);
|
|
1563
|
+
substitutions.set(declaration.name, expression);
|
|
1564
|
+
});
|
|
1565
|
+
implicit.filter(isMissing).forEach((declaration) => {
|
|
1566
|
+
const range = instance.location.range;
|
|
1567
|
+
const declared = declaration.location.range;
|
|
1568
|
+
if (range && declared) {
|
|
1569
|
+
unit.errors.push({
|
|
1570
|
+
location: formatRange(range),
|
|
1571
|
+
message: `Substitution missing for symbol ${declaration.name} declared at ${formatRange(declared)} \nand instantiated in module ${instancer}.`,
|
|
1572
|
+
});
|
|
1573
|
+
}
|
|
709
1574
|
});
|
|
1575
|
+
return substitutions;
|
|
710
1576
|
};
|
|
711
1577
|
|
|
712
|
-
|
|
713
|
-
|
|
714
|
-
|
|
715
|
-
|
|
716
|
-
);
|
|
717
|
-
|
|
718
|
-
|
|
1578
|
+
// Generator.processSubst analyzes an INSTANCE in a LET or a proof, which then binds the names the
|
|
1579
|
+
// INSTANCE adds.
|
|
1580
|
+
const resolveInstance = (instance: Instance, scope: LocalName | undefined, unit: Unit) => {
|
|
1581
|
+
const instanced = unit.getInstance(instance);
|
|
1582
|
+
checkSubstitutions(instance, instanced.declarations, instanced.instancer, scope, unit);
|
|
1583
|
+
return [...instanced.symbols].reduce(
|
|
1584
|
+
(parent, [name, symbol]) => bindName(parent, name, symbol, unit),
|
|
1585
|
+
scope,
|
|
719
1586
|
);
|
|
720
|
-
return symbols;
|
|
721
1587
|
};
|
|
722
1588
|
|
|
1589
|
+
// tla-ts reports what SANY goes on after with an INSTANCE of the module.
|
|
723
1590
|
export const resolveSubstitutions = (
|
|
724
1591
|
instance: Instance,
|
|
725
|
-
declarations:
|
|
1592
|
+
declarations: Declaration[],
|
|
726
1593
|
module: Module,
|
|
727
1594
|
unit: ModuleUnit,
|
|
728
1595
|
) => {
|
|
729
|
-
const
|
|
730
|
-
const
|
|
731
|
-
|
|
1596
|
+
const imported = createSymbols(module, unit.imported);
|
|
1597
|
+
const report: ModuleReport = { location: instance.location, errors: [], warnings: [] };
|
|
1598
|
+
unit.reports.push(report);
|
|
1599
|
+
return checkSubstitutions(instance, declarations, module.name, undefined, {
|
|
1600
|
+
imported,
|
|
1601
|
+
getInstance: unit.getInstance,
|
|
732
1602
|
definitions: unit.definitions,
|
|
733
1603
|
getKey: unit.getKey,
|
|
734
1604
|
location: instance.location,
|
|
735
1605
|
self: undefined,
|
|
736
1606
|
facts: new Set(),
|
|
737
|
-
|
|
738
|
-
|
|
739
|
-
|
|
740
|
-
|
|
741
|
-
|
|
742
|
-
|
|
743
|
-
|
|
744
|
-
|
|
745
|
-
|
|
1607
|
+
goals: new Map(),
|
|
1608
|
+
bindings: new Map(
|
|
1609
|
+
[...imported].map(([name, symbol]) => [name, { ...symbol, position: MODULE_START }]),
|
|
1610
|
+
),
|
|
1611
|
+
errors: report.errors,
|
|
1612
|
+
warnings: report.warnings,
|
|
1613
|
+
hasLabelScope: false,
|
|
1614
|
+
isLabelForbidden: false,
|
|
1615
|
+
isInExcept: false,
|
|
1616
|
+
labelParams: [],
|
|
1617
|
+
labels: new Set(),
|
|
1618
|
+
isGenerated: false,
|
|
746
1619
|
});
|
|
747
|
-
|
|
748
|
-
|
|
749
|
-
|
|
750
|
-
|
|
751
|
-
|
|
752
|
-
|
|
753
|
-
|
|
754
|
-
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
|
|
758
|
-
|
|
759
|
-
|
|
760
|
-
|
|
761
|
-
|
|
762
|
-
|
|
763
|
-
|
|
764
|
-
|
|
765
|
-
|
|
1620
|
+
};
|
|
1621
|
+
|
|
1622
|
+
// SANY reports the errors of every unit it checks, in the order of the units in the module, after
|
|
1623
|
+
// the warnings it reports for the spec. A unit reports to its lists what SANY goes on after, and
|
|
1624
|
+
// throws the error that stops it. An error tla-ts cannot word as SANY does yields to the errors the
|
|
1625
|
+
// unit reported before it. Returns the errors.
|
|
1626
|
+
export const collectSemanticErrors = (
|
|
1627
|
+
units: {
|
|
1628
|
+
location: SourceLocation;
|
|
1629
|
+
check: (reported: SanyError[], warned: SanyError[]) => void;
|
|
1630
|
+
}[],
|
|
1631
|
+
warnings: SanyError[],
|
|
1632
|
+
) => {
|
|
1633
|
+
const errors: SanyError[] = [];
|
|
1634
|
+
const add = (list: SanyError[], item: SanyError) => {
|
|
1635
|
+
if (
|
|
1636
|
+
list.every(
|
|
1637
|
+
(existing) => existing.location !== item.location || existing.message !== item.message,
|
|
1638
|
+
)
|
|
1639
|
+
) {
|
|
1640
|
+
list.push(item);
|
|
1641
|
+
}
|
|
1642
|
+
};
|
|
1643
|
+
units
|
|
1644
|
+
.toSorted((left, right) =>
|
|
1645
|
+
isBefore(left.location, right.location)
|
|
1646
|
+
? -1
|
|
1647
|
+
: isBefore(right.location, left.location)
|
|
1648
|
+
? 1
|
|
1649
|
+
: 0,
|
|
1650
|
+
)
|
|
1651
|
+
.forEach((unit) => {
|
|
1652
|
+
const reported: SanyError[] = [];
|
|
1653
|
+
const warned: SanyError[] = [];
|
|
1654
|
+
try {
|
|
1655
|
+
unit.check(reported, warned);
|
|
1656
|
+
} catch (error) {
|
|
1657
|
+
if (!(error instanceof TlaSyntaxError) || (!error.sany && reported.length === 0)) {
|
|
1658
|
+
throw error;
|
|
1659
|
+
}
|
|
1660
|
+
reported.push(...(error.sany?.errors ?? []));
|
|
766
1661
|
}
|
|
767
|
-
|
|
768
|
-
|
|
769
|
-
|
|
1662
|
+
reported.forEach((item) => add(errors, item));
|
|
1663
|
+
warned.forEach((item) => add(warnings, item));
|
|
1664
|
+
});
|
|
1665
|
+
return errors;
|
|
770
1666
|
};
|
|
771
1667
|
|
|
1668
|
+
// SANY binds the names of a module in the order of its units, and reports a RECURSIVE declaration
|
|
1669
|
+
// that no definition follows at the end. Returns the errors.
|
|
772
1670
|
export const resolveModule = (module: Module, unit: ModuleUnit) => {
|
|
773
1671
|
const symbols = createSymbols(module, unit.imported);
|
|
774
|
-
const facts = new Set(
|
|
775
|
-
|
|
1672
|
+
const facts = new Set([
|
|
1673
|
+
...unit.facts,
|
|
1674
|
+
...[...module.theorems, ...module.assumptions].flatMap((fact) => fact.name ?? []),
|
|
1675
|
+
]);
|
|
1676
|
+
const goals = new Map(
|
|
1677
|
+
module.theorems.flatMap((theorem): [string, Goal][] =>
|
|
1678
|
+
theorem.name !== undefined && theorem.statement.kind === "AssumeProve"
|
|
1679
|
+
? [[theorem.name, { statement: theorem.statement, isSuffices: false, isInProof: false }]]
|
|
1680
|
+
: [],
|
|
1681
|
+
),
|
|
776
1682
|
);
|
|
777
|
-
const
|
|
1683
|
+
const bindings = new Map<string, ModuleBinding>(
|
|
1684
|
+
[...CORE_SYMBOLS, ...unit.bound].map(([name, symbol]) => [
|
|
1685
|
+
name,
|
|
1686
|
+
{ ...symbol, position: MODULE_START },
|
|
1687
|
+
]),
|
|
1688
|
+
);
|
|
1689
|
+
const recursive = new Set<Binding>();
|
|
1690
|
+
const declarations: { declaration: Declaration; binding: ModuleBinding | undefined }[] = [];
|
|
1691
|
+
const createUnit = (
|
|
1692
|
+
location: SourceLocation,
|
|
1693
|
+
self: Definition | undefined,
|
|
1694
|
+
errors: SanyError[],
|
|
1695
|
+
warnings: SanyError[],
|
|
1696
|
+
hasLabelScope: boolean,
|
|
1697
|
+
): Unit => ({
|
|
778
1698
|
imported: symbols,
|
|
1699
|
+
getInstance: unit.getInstance,
|
|
779
1700
|
definitions: unit.definitions,
|
|
780
1701
|
getKey: unit.getKey,
|
|
781
1702
|
location,
|
|
782
1703
|
self,
|
|
783
1704
|
facts,
|
|
1705
|
+
goals,
|
|
1706
|
+
bindings,
|
|
1707
|
+
errors,
|
|
1708
|
+
warnings,
|
|
1709
|
+
hasLabelScope,
|
|
1710
|
+
isLabelForbidden: false,
|
|
1711
|
+
isInExcept: false,
|
|
1712
|
+
labelParams: [],
|
|
1713
|
+
labels: new Set(),
|
|
1714
|
+
isGenerated: false,
|
|
784
1715
|
});
|
|
785
|
-
|
|
786
|
-
|
|
787
|
-
|
|
788
|
-
|
|
789
|
-
|
|
790
|
-
|
|
791
|
-
|
|
792
|
-
|
|
1716
|
+
const bindDeclarations = (declarations: Declaration[], kind: "Constant" | "Variable") =>
|
|
1717
|
+
declarations.map((declaration) => ({
|
|
1718
|
+
location: declaration.location,
|
|
1719
|
+
check: (errors: SanyError[], warnings: SanyError[]) =>
|
|
1720
|
+
bindModuleName(
|
|
1721
|
+
declaration.name,
|
|
1722
|
+
{ kind, arity: declaration.arity, range: declaration.location.range },
|
|
1723
|
+
createUnit(declaration.location, undefined, errors, warnings, false),
|
|
1724
|
+
),
|
|
1725
|
+
}));
|
|
1726
|
+
return collectSemanticErrors(
|
|
1727
|
+
[
|
|
1728
|
+
...unit.reports.map((report) => ({
|
|
1729
|
+
location: report.location,
|
|
1730
|
+
check: (errors: SanyError[], warnings: SanyError[]) => {
|
|
1731
|
+
errors.push(...report.errors);
|
|
1732
|
+
warnings.push(...report.warnings);
|
|
1733
|
+
},
|
|
1734
|
+
})),
|
|
1735
|
+
...bindDeclarations(module.constants, "Constant"),
|
|
1736
|
+
...bindDeclarations(module.variables, "Variable"),
|
|
1737
|
+
...module.units
|
|
1738
|
+
.flatMap((item) => (item.kind === "Recursive" ? item.declarations : []))
|
|
1739
|
+
.map((declaration) => ({
|
|
1740
|
+
location: declaration.location,
|
|
1741
|
+
check: (errors: SanyError[], warnings: SanyError[]) => {
|
|
1742
|
+
const binding: ModuleBinding = {
|
|
1743
|
+
kind: "Definition",
|
|
1744
|
+
arity: declaration.arity,
|
|
1745
|
+
range: declaration.location.range,
|
|
1746
|
+
position: declaration.location,
|
|
1747
|
+
isPending: true,
|
|
1748
|
+
};
|
|
1749
|
+
const isBound = isBindable(
|
|
1750
|
+
declaration.name,
|
|
1751
|
+
bindings.get(declaration.name),
|
|
1752
|
+
binding,
|
|
1753
|
+
createUnit(declaration.location, undefined, errors, warnings, false),
|
|
1754
|
+
);
|
|
1755
|
+
if (isBound) {
|
|
1756
|
+
bindings.set(declaration.name, binding);
|
|
1757
|
+
recursive.add(binding);
|
|
1758
|
+
}
|
|
1759
|
+
declarations.push({ declaration, binding: isBound ? binding : undefined });
|
|
1760
|
+
},
|
|
1761
|
+
})),
|
|
1762
|
+
...module.definitions.map((definition) => ({
|
|
1763
|
+
location: definition.location,
|
|
1764
|
+
check: (errors: SanyError[], warnings: SanyError[]) => {
|
|
1765
|
+
const inner = createUnit(definition.location, definition, errors, warnings, true);
|
|
1766
|
+
if (isTheoremDefinition(module, definition)) {
|
|
1767
|
+
resolveExpression(definition.body, undefined, inner);
|
|
1768
|
+
} else if (resolveDefinition(definition, undefined, inner, recursive)) {
|
|
1769
|
+
bindings.set(definition.name, {
|
|
1770
|
+
kind: "Definition",
|
|
1771
|
+
arity: getArity(definition),
|
|
1772
|
+
range: definition.location.range,
|
|
1773
|
+
position: definition.location,
|
|
1774
|
+
});
|
|
1775
|
+
}
|
|
1776
|
+
},
|
|
1777
|
+
})),
|
|
1778
|
+
...module.instances.map((instance) => ({
|
|
1779
|
+
location: instance.location,
|
|
1780
|
+
check: (errors: SanyError[], warnings: SanyError[]) => {
|
|
1781
|
+
const inner = createUnit(instance.location, undefined, errors, warnings, false);
|
|
1782
|
+
bindParams(undefined, instance.params, inner);
|
|
1783
|
+
unit.instanced
|
|
1784
|
+
.get(instance)
|
|
1785
|
+
?.forEach((symbol, name) => bindModuleName(name, symbol, inner));
|
|
1786
|
+
if (instance.name !== undefined) {
|
|
1787
|
+
bindModuleName(
|
|
1788
|
+
instance.name,
|
|
1789
|
+
{ kind: "Instance", arity: instance.params.length, range: instance.location.range },
|
|
1790
|
+
inner,
|
|
1791
|
+
);
|
|
1792
|
+
}
|
|
1793
|
+
},
|
|
1794
|
+
})),
|
|
1795
|
+
...module.assumptions.map((assumption) => ({
|
|
1796
|
+
location: assumption.location,
|
|
1797
|
+
check: (errors: SanyError[], warnings: SanyError[]) => {
|
|
1798
|
+
const inner = createUnit(
|
|
1799
|
+
assumption.location,
|
|
1800
|
+
undefined,
|
|
1801
|
+
errors,
|
|
1802
|
+
warnings,
|
|
1803
|
+
assumption.name !== undefined,
|
|
1804
|
+
);
|
|
1805
|
+
resolveExpression(assumption.expression, undefined, inner);
|
|
1806
|
+
if (assumption.name !== undefined) {
|
|
1807
|
+
bindModuleName(
|
|
1808
|
+
assumption.name,
|
|
1809
|
+
{ kind: "Theorem", arity: 0, range: assumption.location.range },
|
|
1810
|
+
inner,
|
|
1811
|
+
);
|
|
1812
|
+
}
|
|
1813
|
+
},
|
|
1814
|
+
})),
|
|
1815
|
+
...module.theorems.map((theorem) => ({
|
|
1816
|
+
location: theorem.location,
|
|
1817
|
+
check: (errors: SanyError[], warnings: SanyError[]) =>
|
|
1818
|
+
resolveTheorem(
|
|
1819
|
+
theorem,
|
|
1820
|
+
createUnit(theorem.location, undefined, errors, warnings, theorem.name !== undefined),
|
|
1821
|
+
),
|
|
1822
|
+
})),
|
|
1823
|
+
...module.uses.map((use) => ({
|
|
1824
|
+
location: use.location,
|
|
1825
|
+
check: (errors: SanyError[], warnings: SanyError[]) =>
|
|
1826
|
+
checkFacts(
|
|
1827
|
+
use.facts,
|
|
1828
|
+
undefined,
|
|
1829
|
+
createUnit(use.location, undefined, errors, warnings, false),
|
|
1830
|
+
),
|
|
1831
|
+
})),
|
|
1832
|
+
{
|
|
1833
|
+
location: module.location.range?.end ?? module.location,
|
|
1834
|
+
check: (errors: SanyError[]) =>
|
|
1835
|
+
declarations.forEach((item) => {
|
|
1836
|
+
const range = item.declaration.location.range;
|
|
1837
|
+
if (range && (!item.binding || item.binding.isPending)) {
|
|
1838
|
+
errors.push({
|
|
1839
|
+
location: formatRange(range),
|
|
1840
|
+
message: `Symbol ${item.declaration.name} declared in RECURSIVE statement but not defined.`,
|
|
1841
|
+
});
|
|
1842
|
+
}
|
|
1843
|
+
}),
|
|
1844
|
+
},
|
|
1845
|
+
],
|
|
1846
|
+
unit.warnings,
|
|
793
1847
|
);
|
|
794
1848
|
};
|