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