tla-ts 0.0.10-dev.d618a2d79 → 0.0.10-dev.e5c8dc315
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/compile.cjs +3 -3
- package/dist/compile.js +1 -1
- package/dist/deciders.cjs +36 -36
- package/dist/deciders.js +53 -53
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +18 -4
- package/dist/index.d.ts +18 -4
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove-worker.cjs +1 -1
- package/dist/prove-worker.js +1 -1
- package/dist/prove.cjs +56 -56
- package/dist/prove.js +78 -78
- package/dist/run.cjs +40 -44
- package/dist/run.js +42 -46
- package/dist/tlapm.cjs +1 -1
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +97 -92
- package/dist/transfer.js +97 -92
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +31 -3
- package/src/bags.ts +50 -29
- package/src/builtins.ts +4 -3
- package/src/check-failure.ts +13 -11
- package/src/check-trace.ts +146 -93
- package/src/check.ts +518 -281
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/tlc-arguments.ts +2 -2
- package/src/cli/tlc-output.ts +18 -4
- package/src/cli/tlc.ts +18 -12
- package/src/cli/xml-exporter.ts +1 -1
- package/src/codegen.ts +23 -10
- package/src/coverage.ts +255 -18
- package/src/dependencies.ts +68 -15
- package/src/dfid.ts +101 -36
- package/src/environment.ts +155 -66
- package/src/errors.ts +7 -0
- package/src/evaluate.ts +424 -135
- package/src/exit-codes.ts +28 -14
- package/src/instances.ts +152 -25
- package/src/java-hash.ts +14 -0
- package/src/java-overrides.ts +2 -2
- package/src/levels.ts +675 -236
- package/src/lexer.ts +12 -2
- package/src/liveness-checker.ts +179 -60
- package/src/liveness.ts +55 -10
- package/src/obligations/index.ts +1 -1
- package/src/obligations/normalize.ts +1 -4
- package/src/obligations/printer.ts +5 -5
- package/src/obligations/source.ts +2 -0
- package/src/parallel-worker.ts +8 -2
- package/src/parallel.ts +5 -0
- package/src/parser.ts +180 -149
- package/src/prover/isabelle/isar/attrib.ts +4 -4
- package/src/prover/isabelle/isar/rule-cases.ts +8 -6
- package/src/prover/isabelle/provers/clasimp.ts +1 -1
- package/src/prover/isabelle/provers/hypsubst.ts +2 -2
- package/src/prover/isabelle/pure/rewriter.ts +3 -3
- package/src/prover/isabelle/pure/term.ts +3 -3
- package/src/prover/prep/md5.ts +26 -29
- package/src/prover/smt/rewrite.ts +2 -7
- package/src/prover/smt/simplify.ts +1 -1
- package/src/prover/smt/solver/ackermannize-bv-tactic.ts +3 -2
- package/src/prover/smt/solver/arith-rewriter.ts +11 -3
- package/src/prover/smt/solver/array-rewriter.ts +12 -2
- package/src/prover/smt/solver/asserted-formulas.ts +171 -58
- package/src/prover/smt/solver/ast-lt.ts +1 -1
- package/src/prover/smt/solver/ast.ts +66 -14
- package/src/prover/smt/solver/auf-solver.ts +23 -12
- package/src/prover/smt/solver/bit-blast-tactic.ts +28 -2
- package/src/prover/smt/solver/blast-term-ite.ts +47 -0
- package/src/prover/smt/solver/bound-simplifier.ts +11 -13
- package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
- package/src/prover/smt/solver/bv-rewriter.ts +1 -1
- package/src/prover/smt/solver/bv1-blast.ts +1 -1
- package/src/prover/smt/solver/card2bv.ts +35 -18
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
- package/src/prover/smt/solver/context.ts +84 -15
- package/src/prover/smt/solver/ctx-simplify.ts +9 -4
- package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
- package/src/prover/smt/solver/dependent-expr-state.ts +28 -16
- package/src/prover/smt/solver/diff-neq.ts +9 -8
- package/src/prover/smt/solver/dt2bv-tactic.ts +66 -28
- package/src/prover/smt/solver/elim-bounds.ts +89 -0
- package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +31 -28
- package/src/prover/smt/solver/eq2bv-tactic.ts +15 -6
- package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/egraph.ts +4 -11
- package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
- package/src/prover/smt/solver/euf/mam.ts +1 -5
- package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
- package/src/prover/smt/solver/euf/th-solver.ts +0 -7
- package/src/prover/smt/solver/expr2polynomial.ts +204 -79
- package/src/prover/smt/solver/factor.ts +36 -14
- package/src/prover/smt/solver/fd-solver.ts +608 -139
- package/src/prover/smt/solver/fix-dl-var.ts +2 -3
- package/src/prover/smt/solver/fm-tactic.ts +9 -7
- package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
- package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
- package/src/prover/smt/solver/fpa2bv-tactic.ts +1 -1
- package/src/prover/smt/solver/goal.ts +6 -3
- package/src/prover/smt/solver/goal2nlsat.ts +57 -30
- package/src/prover/smt/solver/hashtable.ts +4 -0
- package/src/prover/smt/solver/internalizer.ts +1 -1
- package/src/prover/smt/solver/lia2pb.ts +1 -1
- package/src/prover/smt/solver/logic-tactics.ts +15 -5
- package/src/prover/smt/solver/lp/core-solver.ts +12 -8
- package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
- package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
- package/src/prover/smt/solver/lp/nla-core.ts +1 -1
- package/src/prover/smt/solver/lp/nla-grobner.ts +158 -80
- package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
- package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
- package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
- package/src/prover/smt/solver/lp/pdd.ts +725 -290
- package/src/prover/smt/solver/lp/union-find.ts +1 -1
- package/src/prover/smt/solver/mam-compiler.ts +1 -1
- package/src/prover/smt/solver/maxcore.ts +2 -1
- package/src/prover/smt/solver/maxsmt-base.ts +1 -0
- package/src/prover/smt/solver/model-based-opt.ts +1 -1
- package/src/prover/smt/solver/model-checker.ts +1 -1
- package/src/prover/smt/solver/model-evaluator.ts +2 -0
- package/src/prover/smt/solver/model-generator.ts +85 -43
- package/src/prover/smt/solver/mpf.ts +2 -4
- package/src/prover/smt/solver/mus.ts +2 -3
- package/src/prover/smt/solver/muz/dl-context.ts +22 -44
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
- package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
- package/src/prover/smt/solver/muz/hnf.ts +2 -2
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
- package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
- package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
- package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
- package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
- package/src/prover/smt/solver/nlqsat.ts +2 -1
- package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
- package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
- package/src/prover/smt/solver/nlsat/explain.ts +375 -217
- package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
- package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
- package/src/prover/smt/solver/nlsat/solver.ts +74 -64
- package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
- package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
- package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
- package/src/prover/smt/solver/nnf.ts +6 -2
- package/src/prover/smt/solver/normalize-bounds.ts +2 -2
- package/src/prover/smt/solver/occf.ts +1 -1
- package/src/prover/smt/solver/opt-context.ts +21 -7
- package/src/prover/smt/solver/opt-nlsat.ts +29 -18
- package/src/prover/smt/solver/opt-pareto.ts +19 -0
- package/src/prover/smt/solver/opt-preprocess.ts +1 -1
- package/src/prover/smt/solver/opt-solver.ts +10 -6
- package/src/prover/smt/solver/optsmt.ts +1 -1
- package/src/prover/smt/solver/parallel-tactic.ts +1 -1
- package/src/prover/smt/solver/pb-rewriter.ts +1 -4
- package/src/prover/smt/solver/pb2bv-tactic.ts +9 -3
- package/src/prover/smt/solver/poly-rewriter.ts +75 -18
- package/src/prover/smt/solver/probes.ts +88 -23
- package/src/prover/smt/solver/proto-model.ts +8 -8
- package/src/prover/smt/solver/purify-arith.ts +51 -49
- package/src/prover/smt/solver/push-app-ite.ts +37 -0
- package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
- package/src/prover/smt/solver/qe-lite.ts +2 -2
- package/src/prover/smt/solver/qe.ts +3 -2
- package/src/prover/smt/solver/qsat.ts +23 -8
- package/src/prover/smt/solver/quantifier-manager.ts +14 -9
- package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
- package/src/prover/smt/solver/reduce-args.ts +2 -2
- package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
- package/src/prover/smt/solver/rewriter.ts +31 -25
- package/src/prover/smt/solver/rlimit.ts +7 -3
- package/src/prover/smt/solver/sat/config.ts +1 -1
- package/src/prover/smt/solver/sat/goal2sat.ts +75 -12
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +149 -47
- package/src/prover/smt/solver/sat/model-converter.ts +1 -1
- package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
- package/src/prover/smt/solver/sat/sat-tactic.ts +54 -25
- package/src/prover/smt/solver/sat/sat2goal.ts +75 -50
- package/src/prover/smt/solver/sat/simplifier.ts +1 -1
- package/src/prover/smt/solver/sat/solver.ts +27 -47
- package/src/prover/smt/solver/seq-axioms.ts +20 -35
- package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
- package/src/prover/smt/solver/seq-derive.ts +2 -2
- package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
- package/src/prover/smt/solver/seq-monadic.ts +7 -5
- package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
- package/src/prover/smt/solver/seq-re-util.ts +1 -1
- package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
- package/src/prover/smt/solver/seq-regex-live.ts +2 -2
- package/src/prover/smt/solver/seq-rewriter.ts +31 -29
- package/src/prover/smt/solver/seq-skolem.ts +0 -23
- package/src/prover/smt/solver/seq-view-witness.ts +4 -4
- package/src/prover/smt/solver/smt-consequences.ts +1 -1
- package/src/prover/smt/solver/smt-kernel.ts +48 -7
- package/src/prover/smt/solver/smt-setup.ts +106 -13
- package/src/prover/smt/solver/smtlib-parser.ts +589 -224
- package/src/prover/smt/solver/smtlib-script.ts +718 -213
- package/src/prover/smt/solver/solve-eqs.ts +36 -37
- package/src/prover/smt/solver/solver.ts +18 -4
- package/src/prover/smt/solver/tactic.ts +389 -199
- package/src/prover/smt/solver/theory-bv.ts +13 -3
- package/src/prover/smt/solver/theory-fpa.ts +1 -1
- package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
- package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
- package/src/prover/smt/solver/theory-lra-propagate.ts +12 -3
- package/src/prover/smt/solver/theory-lra-state.ts +1 -1
- package/src/prover/smt/solver/theory-lra.ts +1 -1
- package/src/prover/smt/solver/theory-pb.ts +24 -7
- package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
- package/src/prover/smt/solver/theory-seq-state.ts +2 -21
- package/src/prover/smt/solver/theory-without-terms.ts +24 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +15 -5
- package/src/prover/tlapm/cache.ts +8 -8
- package/src/prover/zenon/index-table.ts +5 -2
- package/src/prover/zenon/isar-case.ts +1 -1
- package/src/prover/zenon/isar.ts +2 -2
- package/src/prover/zenon/phrase.ts +1 -1
- package/src/resolve.ts +1311 -268
- package/src/runtime.ts +21 -2
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +5 -15
- package/src/sany/generator-def-entries.ts +123 -36
- package/src/sany/generator-definitions.ts +5 -3
- package/src/sany/generator-expressions.ts +60 -37
- package/src/sany/generator-proofs.ts +19 -12
- package/src/sany/generator.ts +12 -6
- package/src/sany/lexer.ts +15 -7
- package/src/sany/modules.ts +4 -2
- package/src/sany/nodes.ts +1 -1
- package/src/sany/selectors.ts +12 -6
- package/src/sany/xml.ts +2 -3
- package/src/search.ts +321 -135
- package/src/simulate.ts +247 -185
- package/src/spec-description.ts +15 -7
- package/src/standard-definitions.ts +1 -0
- package/src/standard-modules.ts +56 -22
- package/src/subexpressions.ts +666 -147
- package/src/successors.ts +50 -20
- package/src/symmetry.ts +2 -1
- package/src/tlc/jar-data.ts +10 -0
- package/src/tlc/messages.ts +3 -3
- package/src/tlc/order.ts +14 -3
- package/src/tlc/random.ts +2 -1
- package/src/tlc/replay.ts +147 -46
- package/src/tlc/tlc-operators.ts +10 -8
- package/src/tlc/tlcext-operators.ts +44 -15
- package/src/tlc/trace-spec.ts +9 -22
- package/src/trace-liveness.ts +529 -0
- package/src/typed-tier.ts +52 -31
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +150 -79
package/src/evaluate.ts
CHANGED
|
@@ -1,5 +1,6 @@
|
|
|
1
1
|
import {
|
|
2
2
|
getChildren,
|
|
3
|
+
getFunctionConstruction,
|
|
3
4
|
getReferencedName,
|
|
4
5
|
isLocallyResolved,
|
|
5
6
|
type Bound,
|
|
@@ -22,13 +23,27 @@ import {
|
|
|
22
23
|
} from "./errors";
|
|
23
24
|
import { EXIT_STATUS, setExitCode } from "./exit-codes";
|
|
24
25
|
import { generateEvaluator } from "./codegen";
|
|
25
|
-
import {
|
|
26
|
+
import {
|
|
27
|
+
chargeContexts,
|
|
28
|
+
chargeFunctionConstruction,
|
|
29
|
+
chargeSetOperation,
|
|
30
|
+
costCoverage,
|
|
31
|
+
countCoverage,
|
|
32
|
+
createChargedEnumerator,
|
|
33
|
+
createProductSetEnumerator,
|
|
34
|
+
getCoverageNode,
|
|
35
|
+
runAtCoverageNode,
|
|
36
|
+
tagSubset,
|
|
37
|
+
type Coverage,
|
|
38
|
+
} from "./coverage";
|
|
26
39
|
import { MESSAGE_CODE } from "./tlc/messages";
|
|
27
40
|
import type { CheckerRuntime } from "./runtime";
|
|
28
41
|
import {
|
|
29
|
-
|
|
42
|
+
isEvaluatedAtStartup,
|
|
43
|
+
isExpressionImpure,
|
|
30
44
|
isImpureDefinition,
|
|
31
45
|
isNonconstant,
|
|
46
|
+
isTlcEvalReached,
|
|
32
47
|
type DefinitionFacts,
|
|
33
48
|
} from "./dependencies";
|
|
34
49
|
import { contextualApplications, substitutionFrames } from "./instances";
|
|
@@ -152,6 +167,7 @@ export interface Environment {
|
|
|
152
167
|
variableIndex: Map<string, number>;
|
|
153
168
|
facts: DefinitionFacts;
|
|
154
169
|
startupValues: (Value | undefined)[];
|
|
170
|
+
tlcEvalValues: WeakMap<Expression, Value>;
|
|
155
171
|
substitutedDefinitions: Set<Definition>;
|
|
156
172
|
instanceParams: Set<OperatorParam>;
|
|
157
173
|
evaluators: WeakMap<Expression, Evaluator>;
|
|
@@ -320,15 +336,14 @@ export const getDomainOperator = (expression: Expression) => (value: Value) => {
|
|
|
320
336
|
};
|
|
321
337
|
|
|
322
338
|
export const getSubsetOperator =
|
|
323
|
-
(expression: Expression,
|
|
339
|
+
(expression: Expression, subset: (left: Value, right: Value) => Value) =>
|
|
340
|
+
(left: Value, right: Value) => {
|
|
324
341
|
if (!isSetValue(left) || isOverriddenSet(left)) {
|
|
325
342
|
throw new TlaEvaluationError(
|
|
326
343
|
`Attempted to evaluate an expression of form S \\subseteq T, but S was not enumerable.\n${describeRange(expression)}`,
|
|
327
344
|
);
|
|
328
345
|
}
|
|
329
|
-
return
|
|
330
|
-
? builtin.evaluateBinary(left, right)
|
|
331
|
-
: builtin.evaluate([left, right]);
|
|
346
|
+
return subset(left, right);
|
|
332
347
|
};
|
|
333
348
|
|
|
334
349
|
export const createRealNumberError = (expression: DecimalExpression) =>
|
|
@@ -523,10 +538,13 @@ const someElement = (
|
|
|
523
538
|
return false;
|
|
524
539
|
};
|
|
525
540
|
|
|
526
|
-
export const mapBoundSets = <Result>(
|
|
541
|
+
export const mapBoundSets = <Result>(
|
|
542
|
+
bounds: Bound[],
|
|
543
|
+
map: (set: Expression, index: number) => Result,
|
|
544
|
+
) =>
|
|
527
545
|
bounds.reduce<Result[]>((results, bound, index) => {
|
|
528
546
|
results.push(
|
|
529
|
-
index > 0 && bounds[index - 1].set === bound.set ? results[index - 1] : map(bound.set),
|
|
547
|
+
index > 0 && bounds[index - 1].set === bound.set ? results[index - 1] : map(bound.set, index),
|
|
530
548
|
);
|
|
531
549
|
return results;
|
|
532
550
|
}, []);
|
|
@@ -557,6 +575,31 @@ export const forEachBinding = (
|
|
|
557
575
|
visit: (scope: Scope | undefined) => boolean,
|
|
558
576
|
) => forEachBoundElement(bounds, getBoundElements(bounds, context), context.scope, visit);
|
|
559
577
|
|
|
578
|
+
const forEachChargedBinding = (
|
|
579
|
+
bounds: Bound[],
|
|
580
|
+
context: Context,
|
|
581
|
+
coverage: Coverage,
|
|
582
|
+
visit: (scope: Scope | undefined) => boolean,
|
|
583
|
+
) => {
|
|
584
|
+
const bounded = mapBoundSets(bounds, (set) => {
|
|
585
|
+
const value = evaluate(set, context);
|
|
586
|
+
return {
|
|
587
|
+
value,
|
|
588
|
+
elements: getQuantifierElements(value, set, context.environment.runtime.version),
|
|
589
|
+
};
|
|
590
|
+
});
|
|
591
|
+
const sets = bounded.map((item) => item.elements);
|
|
592
|
+
const charge = chargeContexts(
|
|
593
|
+
coverage,
|
|
594
|
+
bounded.map((item) => item.value),
|
|
595
|
+
sets,
|
|
596
|
+
);
|
|
597
|
+
return forEachBoundElement(bounds, sets, context.scope, (scope) => {
|
|
598
|
+
charge();
|
|
599
|
+
return visit(scope);
|
|
600
|
+
});
|
|
601
|
+
};
|
|
602
|
+
|
|
560
603
|
const getBoundsDomain = (bounds: Bound[], context: Context): Value => {
|
|
561
604
|
const sets = mapBoundSets(bounds, (set) => evaluate(set, context));
|
|
562
605
|
return sets.length === 1 ? sets[0] : { kind: "ProductSet", factors: sets };
|
|
@@ -615,12 +658,16 @@ export const bindLazyArguments = (
|
|
|
615
658
|
typeof value.domain === "object" && value.domain.kind === "ProductSet"
|
|
616
659
|
? value.domain.factors
|
|
617
660
|
: [];
|
|
618
|
-
|
|
661
|
+
if (elements === undefined) {
|
|
662
|
+
throw new TlaEvaluationError(
|
|
663
|
+
`Attempted to apply a function to an argument not in its domain.\n${describeRange(expression.function)}`,
|
|
664
|
+
);
|
|
665
|
+
}
|
|
666
|
+
// Deviation from TLC: Tool#getFcnContext indexes past an argument tuple shorter than the bounds and ignores a longer one.
|
|
619
667
|
const createListError = () =>
|
|
620
668
|
new TlaEvaluationError(
|
|
621
669
|
`In applying the function\n${prettyPrint(formatValue(value))},\nthe argument list is:\n${prettyPrint(formatValue(argument))}\nwhich does not match its formal parameter.\n`,
|
|
622
670
|
);
|
|
623
|
-
if (elements === undefined) throw createListError();
|
|
624
671
|
bounds.forEach((bound, index) => {
|
|
625
672
|
if (index >= elements.length) throw createListError();
|
|
626
673
|
const element = elements[index];
|
|
@@ -669,7 +716,7 @@ const getLazyFunctionTemplate = (bounds: Bound[], body: Expression) => {
|
|
|
669
716
|
},
|
|
670
717
|
],
|
|
671
718
|
),
|
|
672
|
-
body:
|
|
719
|
+
body: describeNode(body),
|
|
673
720
|
};
|
|
674
721
|
};
|
|
675
722
|
|
|
@@ -715,28 +762,29 @@ const getBoundTupleLengths = (bounds: Bound[]) =>
|
|
|
715
762
|
bound.pattern.kind === "Tuple" ? bound.pattern.names.length : undefined,
|
|
716
763
|
);
|
|
717
764
|
|
|
718
|
-
const getDefinitionSource = (definition: FunctionDefinition): Expression => ({
|
|
719
|
-
kind: "FunctionConstruction",
|
|
720
|
-
bounds: definition.bounds,
|
|
721
|
-
body: definition.body,
|
|
722
|
-
location: definition.location,
|
|
723
|
-
});
|
|
724
|
-
|
|
725
765
|
const createRecursiveFunction = (
|
|
726
766
|
definition: FunctionDefinition,
|
|
727
767
|
context: Context,
|
|
728
768
|
): RebindableLazyFunction => {
|
|
729
769
|
const domain = getBoundsDomain(definition.bounds, context);
|
|
770
|
+
const compute = (argument: Value, self: Value) =>
|
|
771
|
+
evaluate(
|
|
772
|
+
definition.body,
|
|
773
|
+
withScope(
|
|
774
|
+
context,
|
|
775
|
+
bindArgument(definition.bounds, bindValue(undefined, definition.name, self), argument),
|
|
776
|
+
),
|
|
777
|
+
);
|
|
778
|
+
const coverage = context.environment.coverage;
|
|
779
|
+
const node = coverage && !context.environment.callStack ? coverage.current : -1;
|
|
730
780
|
const functionValue = createLazyFunction(
|
|
731
781
|
domain,
|
|
732
|
-
|
|
733
|
-
|
|
734
|
-
|
|
735
|
-
|
|
736
|
-
|
|
737
|
-
|
|
738
|
-
),
|
|
739
|
-
),
|
|
782
|
+
coverage
|
|
783
|
+
? (argument, self) =>
|
|
784
|
+
coverage.current === -1
|
|
785
|
+
? compute(argument, self)
|
|
786
|
+
: runAtCoverageNode(coverage, node, () => compute(argument, self))
|
|
787
|
+
: compute,
|
|
740
788
|
getLazyFunctionSource(
|
|
741
789
|
getLazyFunctionTemplate(definition.bounds, definition.body),
|
|
742
790
|
definition.bounds,
|
|
@@ -788,9 +836,17 @@ const compileDefinitionBody = (definition: Definition, environment: Environment)
|
|
|
788
836
|
};
|
|
789
837
|
}
|
|
790
838
|
if (definition.kind !== "Function") return getEntryEvaluator(definition.body, environment);
|
|
791
|
-
|
|
792
|
-
|
|
793
|
-
|
|
839
|
+
const construction = getFunctionConstruction(definition, false);
|
|
840
|
+
if (!definition.isSelfReferential) return getEntryEvaluator(construction, environment);
|
|
841
|
+
const evaluator: Evaluator = (context) => createRecursiveFunction(definition, context);
|
|
842
|
+
const coverage = environment.coverage;
|
|
843
|
+
return coverage ? countEvaluator(construction, evaluator, coverage) : evaluator;
|
|
844
|
+
};
|
|
845
|
+
|
|
846
|
+
const CALLER_SCOPE: Scope = {
|
|
847
|
+
name: "",
|
|
848
|
+
binding: { kind: "Value", value: false },
|
|
849
|
+
parent: undefined,
|
|
794
850
|
};
|
|
795
851
|
|
|
796
852
|
const getDefinitionEvaluator = (definition: Definition, environment: Environment): Evaluator => {
|
|
@@ -799,8 +855,15 @@ const getDefinitionEvaluator = (definition: Definition, environment: Environment
|
|
|
799
855
|
const body = compileDefinitionBody(definition, environment);
|
|
800
856
|
const definitionId = environment.facts.ids.get(definition);
|
|
801
857
|
const startupValues = environment.startupValues;
|
|
802
|
-
const
|
|
803
|
-
|
|
858
|
+
const isInCallerContext =
|
|
859
|
+
definition.kind === "Operator" &&
|
|
860
|
+
definition.params.length === 0 &&
|
|
861
|
+
isTlcEvalReached(definition.body, environment);
|
|
862
|
+
const evaluator: Evaluator = isInCallerContext
|
|
863
|
+
? (context) =>
|
|
864
|
+
(definitionId === undefined ? undefined : startupValues[definitionId]) ??
|
|
865
|
+
body(withScope(context, isTlcContextEmpty(context.scope) ? undefined : CALLER_SCOPE))
|
|
866
|
+
: definitionId === undefined
|
|
804
867
|
? (context) => body(withScope(context, undefined))
|
|
805
868
|
: (context) => startupValues[definitionId] ?? body(withScope(context, undefined));
|
|
806
869
|
environment.definitionEvaluators.set(definition, evaluator);
|
|
@@ -817,7 +880,7 @@ export const evaluateStartupDefinitions = (definitions: Definition[], environmen
|
|
|
817
880
|
if (definition.kind === "Operator" && definition.params.length > 0) return;
|
|
818
881
|
const name = definition.name;
|
|
819
882
|
if (environment.constants.has(name) || environment.substitutions.has(name)) return;
|
|
820
|
-
if (!
|
|
883
|
+
if (!isEvaluatedAtStartup(definition, environment)) return;
|
|
821
884
|
const definitionId = environment.facts.ids.get(definition);
|
|
822
885
|
if (definitionId === undefined || environment.startupValues[definitionId] !== undefined) return;
|
|
823
886
|
const context = { environment, scope: undefined, state: undefined, next: undefined };
|
|
@@ -969,6 +1032,7 @@ const isOperatorArgument = (expression: Expression, context: Context) => {
|
|
|
969
1032
|
return operator !== undefined && getArity(operator) > 0;
|
|
970
1033
|
};
|
|
971
1034
|
|
|
1035
|
+
// Deviation from TLC: SymbolNodeValueLookupProvider#lookup takes an operator whose body is a literal for that literal, so a Java override rejects it as an argument.
|
|
972
1036
|
const evaluateBuiltinArguments = (args: Expression[], context: Context) =>
|
|
973
1037
|
args.map((arg) =>
|
|
974
1038
|
isOperatorArgument(arg, context)
|
|
@@ -1083,20 +1147,29 @@ interface ReevaluatedDefinitions {
|
|
|
1083
1147
|
streamed: ReadonlySet<Definition>;
|
|
1084
1148
|
}
|
|
1085
1149
|
|
|
1086
|
-
const
|
|
1150
|
+
const isRecursiveOperator = (definition: Definition) =>
|
|
1151
|
+
definition.kind === "Operator" && definition.isRecursive && definition.params.length > 0;
|
|
1087
1152
|
|
|
1088
|
-
|
|
1089
|
-
|
|
1090
|
-
|
|
1091
|
-
|
|
1092
|
-
|
|
1093
|
-
|
|
1094
|
-
|
|
1095
|
-
|
|
1096
|
-
|
|
1097
|
-
|
|
1098
|
-
|
|
1099
|
-
|
|
1153
|
+
// TLC finds a RECURSIVE operator with parameters by its definition, not in its context, so every definition reaches it.
|
|
1154
|
+
const chainRecursiveOperatorsFirst = (
|
|
1155
|
+
definitions: Definition[],
|
|
1156
|
+
nodes: Scope[],
|
|
1157
|
+
outer: Scope | undefined,
|
|
1158
|
+
) => {
|
|
1159
|
+
let scope = outer;
|
|
1160
|
+
for (let index = 0; index < definitions.length; index++) {
|
|
1161
|
+
if (isRecursiveOperator(definitions[index])) {
|
|
1162
|
+
nodes[index].parent = scope;
|
|
1163
|
+
scope = nodes[index];
|
|
1164
|
+
}
|
|
1165
|
+
}
|
|
1166
|
+
for (let index = 0; index < definitions.length; index++) {
|
|
1167
|
+
if (!isRecursiveOperator(definitions[index])) {
|
|
1168
|
+
nodes[index].parent = scope;
|
|
1169
|
+
scope = nodes[index];
|
|
1170
|
+
}
|
|
1171
|
+
}
|
|
1172
|
+
return scope;
|
|
1100
1173
|
};
|
|
1101
1174
|
|
|
1102
1175
|
export const bindDefinitions = (
|
|
@@ -1109,16 +1182,29 @@ export const bindDefinitions = (
|
|
|
1109
1182
|
binding: { kind: "Value", value: false },
|
|
1110
1183
|
parent: undefined,
|
|
1111
1184
|
}));
|
|
1112
|
-
|
|
1113
|
-
|
|
1114
|
-
|
|
1115
|
-
|
|
1116
|
-
|
|
1185
|
+
let scope = context.scope;
|
|
1186
|
+
let hasRecursive = false;
|
|
1187
|
+
for (let index = 0; index < nodes.length; index++) {
|
|
1188
|
+
nodes[index].parent = scope;
|
|
1189
|
+
scope = nodes[index];
|
|
1190
|
+
hasRecursive ||= definitions[index].isRecursive;
|
|
1191
|
+
}
|
|
1192
|
+
if (hasRecursive) scope = chainRecursiveOperatorsFirst(definitions, nodes, context.scope);
|
|
1193
|
+
let isRecursiveValueAtOrAfter = false;
|
|
1194
|
+
for (let index = definitions.length - 1; index >= 0; index--) {
|
|
1195
|
+
const definition = definitions[index];
|
|
1196
|
+
isRecursiveValueAtOrAfter ||=
|
|
1197
|
+
definition.isRecursive && definition.kind === "Operator" && definition.params.length === 0;
|
|
1198
|
+
// TLC's LET evaluates an operator without parameters in the context before it, which TLCEval#tlcEval tells from an empty one.
|
|
1199
|
+
const ownScope =
|
|
1200
|
+
definition.kind === "Operator" && definition.params.length === 0 && !isRecursiveValueAtOrAfter
|
|
1201
|
+
? nodes[index].parent
|
|
1202
|
+
: scope;
|
|
1117
1203
|
nodes[index].binding =
|
|
1118
1204
|
definition.kind === "Function"
|
|
1119
1205
|
? {
|
|
1120
1206
|
kind: "Thunk",
|
|
1121
|
-
expression:
|
|
1207
|
+
expression: getFunctionConstruction(definition, true),
|
|
1122
1208
|
scope,
|
|
1123
1209
|
state: context.state,
|
|
1124
1210
|
next: context.next,
|
|
@@ -1133,19 +1219,19 @@ export const bindDefinitions = (
|
|
|
1133
1219
|
name: definition.name,
|
|
1134
1220
|
params: definition.params,
|
|
1135
1221
|
body: definition.body,
|
|
1136
|
-
scope,
|
|
1222
|
+
scope: ownScope,
|
|
1137
1223
|
},
|
|
1138
1224
|
}
|
|
1139
1225
|
: {
|
|
1140
1226
|
kind: "Thunk",
|
|
1141
1227
|
expression: definition.body,
|
|
1142
|
-
scope,
|
|
1228
|
+
scope: ownScope,
|
|
1143
1229
|
state: context.state,
|
|
1144
1230
|
next: context.next,
|
|
1145
1231
|
cache: undefined,
|
|
1146
1232
|
isStreamed: reevaluated?.streamed.has(definition) ?? false,
|
|
1147
1233
|
};
|
|
1148
|
-
}
|
|
1234
|
+
}
|
|
1149
1235
|
const coverage = context.environment.coverage;
|
|
1150
1236
|
if (coverage && coverage.current !== -1) {
|
|
1151
1237
|
nodes.forEach((node) => {
|
|
@@ -1175,16 +1261,22 @@ const evaluateLocalIdentifier = (name: string, expression: Expression, context:
|
|
|
1175
1261
|
if (global?.kind === "Definition") {
|
|
1176
1262
|
return getDefinitionEvaluator(global.definition, context.environment)(context);
|
|
1177
1263
|
}
|
|
1178
|
-
const builtin = context.environment.builtins.get(
|
|
1264
|
+
const builtin = context.environment.builtins.get(
|
|
1265
|
+
context.environment.substitutions.get(name) ?? name,
|
|
1266
|
+
);
|
|
1179
1267
|
if (builtin?.arity === 0) return builtin.evaluate([], context);
|
|
1180
|
-
throw new TlaEvaluationError(
|
|
1268
|
+
throw new TlaEvaluationError(
|
|
1269
|
+
`In evaluation, the identifier ${name} is either undefined or not an operator.\n${describeRange(expression)}`,
|
|
1270
|
+
);
|
|
1181
1271
|
};
|
|
1182
1272
|
|
|
1183
1273
|
export const getReevaluatedDefinitions = (
|
|
1184
1274
|
definitions: Definition[],
|
|
1185
1275
|
environment: Environment,
|
|
1186
1276
|
): ReevaluatedDefinitions => ({
|
|
1187
|
-
impure: new Set(
|
|
1277
|
+
impure: new Set(
|
|
1278
|
+
definitions.filter((definition) => isImpureDefinition(definition, environment, "varying")),
|
|
1279
|
+
),
|
|
1188
1280
|
streamed: new Set(
|
|
1189
1281
|
definitions.filter((definition) => isImpureDefinition(definition, environment, "streamed")),
|
|
1190
1282
|
),
|
|
@@ -1316,7 +1408,6 @@ const headFingerprint = (callStack: CallStack, source: Expression, error: unknow
|
|
|
1316
1408
|
|
|
1317
1409
|
export const createTracingEnvironment = (environment: Environment): Environment => ({
|
|
1318
1410
|
...environment,
|
|
1319
|
-
coverage: undefined,
|
|
1320
1411
|
evaluators: new WeakMap(),
|
|
1321
1412
|
entryEvaluators: new WeakMap(),
|
|
1322
1413
|
definitionEvaluators: new WeakMap(),
|
|
@@ -1329,6 +1420,41 @@ export const createTracingEnvironment = (environment: Environment): Environment
|
|
|
1329
1420
|
},
|
|
1330
1421
|
});
|
|
1331
1422
|
|
|
1423
|
+
// TLC evaluates `a /\ b /\ c` as `(a /\ b) /\ c`, so its call stack holds each prefix.
|
|
1424
|
+
const compileTracedJunction = (
|
|
1425
|
+
expression: Expression & { kind: "And" | "Or" },
|
|
1426
|
+
operands: Evaluator[],
|
|
1427
|
+
callStack: CallStack | undefined,
|
|
1428
|
+
): Evaluator | undefined => {
|
|
1429
|
+
const range = expression.location.range;
|
|
1430
|
+
const prefixEnds = expression.prefixEnds;
|
|
1431
|
+
if (!callStack || expression.isBulleted || !range || !prefixEnds || operands.length < 3) {
|
|
1432
|
+
return undefined;
|
|
1433
|
+
}
|
|
1434
|
+
const prefixes = prefixEnds
|
|
1435
|
+
.slice(0, operands.length - 2)
|
|
1436
|
+
.map((end) => ({
|
|
1437
|
+
...expression,
|
|
1438
|
+
location: { ...expression.location, range: { ...range, end } },
|
|
1439
|
+
}))
|
|
1440
|
+
.reverse();
|
|
1441
|
+
const isAnd = expression.kind === "And";
|
|
1442
|
+
return (context) => {
|
|
1443
|
+
callStack.expressions.push(...prefixes);
|
|
1444
|
+
for (let index = 0; index < operands.length; index++) {
|
|
1445
|
+
if (index >= 2 && !callStack.isFrozen) callStack.expressions.pop();
|
|
1446
|
+
const value = operands[index](context);
|
|
1447
|
+
if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
|
|
1448
|
+
if (value !== isAnd) {
|
|
1449
|
+
if (!callStack.isFrozen)
|
|
1450
|
+
callStack.expressions.length -= prefixes.length - Math.max(index - 1, 0);
|
|
1451
|
+
return value;
|
|
1452
|
+
}
|
|
1453
|
+
}
|
|
1454
|
+
return isAnd;
|
|
1455
|
+
};
|
|
1456
|
+
};
|
|
1457
|
+
|
|
1332
1458
|
const traceFrames =
|
|
1333
1459
|
(
|
|
1334
1460
|
expression: Expression,
|
|
@@ -1356,9 +1482,21 @@ const countEvaluator =
|
|
|
1356
1482
|
coverage.current = node;
|
|
1357
1483
|
try {
|
|
1358
1484
|
const value = evaluator(context);
|
|
1359
|
-
|
|
1360
|
-
|
|
1361
|
-
|
|
1485
|
+
const isTagged =
|
|
1486
|
+
expression.kind === "SetEnumeration" ||
|
|
1487
|
+
((expression.kind === "SetFilter" || expression.kind === "SetMap") &&
|
|
1488
|
+
isReducibleSet(value)) ||
|
|
1489
|
+
(expression.kind === "SetFilter" &&
|
|
1490
|
+
typeof value === "object" &&
|
|
1491
|
+
value.kind === "FilteredSet") ||
|
|
1492
|
+
((expression.kind === "FunctionSet" || expression.kind === "RecordSet") &&
|
|
1493
|
+
typeof value === "object" &&
|
|
1494
|
+
value.kind === expression.kind) ||
|
|
1495
|
+
(expression.kind === "Apply" &&
|
|
1496
|
+
expression.operator === "SUBSET" &&
|
|
1497
|
+
typeof value === "object" &&
|
|
1498
|
+
value.kind === "Subset");
|
|
1499
|
+
if (typeof value === "object" && isTagged) coverage.values.set(value, node);
|
|
1362
1500
|
return value;
|
|
1363
1501
|
} finally {
|
|
1364
1502
|
coverage.current = outer;
|
|
@@ -1508,6 +1646,26 @@ const compileClosureCall = (
|
|
|
1508
1646
|
};
|
|
1509
1647
|
};
|
|
1510
1648
|
|
|
1649
|
+
// TLC's LET conses only its arity-0 definitions onto the context that TLCEval#tlcEval caches under when it is empty.
|
|
1650
|
+
const isTlcContextEmpty = (scope: Scope | undefined) => {
|
|
1651
|
+
for (let node = scope; node !== undefined; node = node.parent) {
|
|
1652
|
+
const binding = node.binding;
|
|
1653
|
+
if (
|
|
1654
|
+
binding.kind !== "Operator" ||
|
|
1655
|
+
binding.operator.kind !== "Closure" ||
|
|
1656
|
+
binding.operator.params.length === 0
|
|
1657
|
+
) {
|
|
1658
|
+
return false;
|
|
1659
|
+
}
|
|
1660
|
+
let letScope = binding.operator.scope;
|
|
1661
|
+
while (letScope !== undefined && letScope !== node) letScope = letScope.parent;
|
|
1662
|
+
if (letScope !== node) return false;
|
|
1663
|
+
}
|
|
1664
|
+
return true;
|
|
1665
|
+
};
|
|
1666
|
+
|
|
1667
|
+
const SET_OPERATORS = new Set(["\\cup", "\\cap", "\\"]);
|
|
1668
|
+
|
|
1511
1669
|
const compileApply = (
|
|
1512
1670
|
expression: Expression & { kind: "Apply" },
|
|
1513
1671
|
environment: Environment,
|
|
@@ -1547,19 +1705,63 @@ const compileApply = (
|
|
|
1547
1705
|
return (context) => domain(operand(context));
|
|
1548
1706
|
}
|
|
1549
1707
|
if (global?.kind === "Builtin" && global.name === "TLCEval" && args.length === 1) {
|
|
1708
|
+
// Deviation from TLC: TLCEval#tlcEval evaluates an argument SANY takes for constant, such as Print(v, TRUE), in an empty state.
|
|
1550
1709
|
const isCached =
|
|
1551
1710
|
!contextualApplications.has(expression) && !isNonconstant(args[0], environment);
|
|
1552
|
-
|
|
1553
|
-
|
|
1554
|
-
|
|
1555
|
-
|
|
1556
|
-
|
|
1711
|
+
const tlcEvalValues = environment.tlcEvalValues;
|
|
1712
|
+
return (context) => {
|
|
1713
|
+
if (!isCached || !isTlcContextEmpty(context.scope)) {
|
|
1714
|
+
return global.evaluate(getLazyArguments(args, context), context);
|
|
1715
|
+
}
|
|
1716
|
+
const cached = tlcEvalValues.get(expression);
|
|
1717
|
+
if (cached !== undefined) return cached;
|
|
1718
|
+
const value = global.evaluate(getLazyArguments(args, context), undefined);
|
|
1719
|
+
tlcEvalValues.set(expression, value);
|
|
1720
|
+
return value;
|
|
1721
|
+
};
|
|
1722
|
+
}
|
|
1723
|
+
if (
|
|
1724
|
+
global?.kind === "Builtin" &&
|
|
1725
|
+
global.name === "\\subseteq" &&
|
|
1726
|
+
global.evaluateBinary &&
|
|
1727
|
+
args.length === 2
|
|
1728
|
+
) {
|
|
1729
|
+
const left = getEvaluator(args[0], environment);
|
|
1730
|
+
const right = getEvaluator(args[1], environment);
|
|
1731
|
+
const subset = getSubsetOperator(expression, global.evaluateBinary);
|
|
1732
|
+
const coverage = environment.coverage;
|
|
1733
|
+
if (!coverage) return (context) => subset(left(context), right(context));
|
|
1734
|
+
return (context) => {
|
|
1735
|
+
const leftValue = left(context);
|
|
1736
|
+
const rightValue = right(context);
|
|
1737
|
+
if (
|
|
1738
|
+
typeof leftValue !== "object" ||
|
|
1739
|
+
leftValue.kind !== "Set" ||
|
|
1740
|
+
!coverage.values.has(leftValue)
|
|
1741
|
+
) {
|
|
1742
|
+
return subset(leftValue, rightValue);
|
|
1743
|
+
}
|
|
1744
|
+
const missing = leftValue.elements.findIndex((element) => !isElementOf(element, rightValue));
|
|
1745
|
+
costCoverage(coverage, leftValue, (missing === -1 ? leftValue.elements.length : missing) + 1);
|
|
1746
|
+
return missing === -1;
|
|
1747
|
+
};
|
|
1557
1748
|
}
|
|
1558
|
-
|
|
1749
|
+
const coverage = environment.coverage;
|
|
1750
|
+
const combine = global?.kind === "Builtin" ? global.evaluateBinary : undefined;
|
|
1751
|
+
if (coverage && combine && SET_OPERATORS.has(expression.operator) && args.length === 2) {
|
|
1559
1752
|
const left = getEvaluator(args[0], environment);
|
|
1560
1753
|
const right = getEvaluator(args[1], environment);
|
|
1561
|
-
|
|
1562
|
-
|
|
1754
|
+
return (context) => {
|
|
1755
|
+
const leftValue = left(context);
|
|
1756
|
+
const rightValue = right(context);
|
|
1757
|
+
return chargeSetOperation(
|
|
1758
|
+
coverage,
|
|
1759
|
+
expression.operator,
|
|
1760
|
+
leftValue,
|
|
1761
|
+
rightValue,
|
|
1762
|
+
combine(leftValue, rightValue),
|
|
1763
|
+
);
|
|
1764
|
+
};
|
|
1563
1765
|
}
|
|
1564
1766
|
if (global?.kind === "Builtin") return compileBuiltinCall(global, args, environment);
|
|
1565
1767
|
if (expression.operator === "\\cdot" && args.length === 2) {
|
|
@@ -1592,6 +1794,18 @@ const compileQuantifier = (
|
|
|
1592
1794
|
const isForall = expression.kind === "Forall";
|
|
1593
1795
|
const body = getEvaluator(expression.body, environment);
|
|
1594
1796
|
const bound = expression.bounds[0];
|
|
1797
|
+
const coverage = environment.coverage;
|
|
1798
|
+
if (coverage) {
|
|
1799
|
+
return (context) => {
|
|
1800
|
+
const isFound = forEachChargedBinding(
|
|
1801
|
+
expression.bounds,
|
|
1802
|
+
context,
|
|
1803
|
+
coverage,
|
|
1804
|
+
(scope) => expectBooleanBody(body(withScope(context, scope)), expression) !== isForall,
|
|
1805
|
+
);
|
|
1806
|
+
return isFound ? !isForall : isForall;
|
|
1807
|
+
};
|
|
1808
|
+
}
|
|
1595
1809
|
if (expression.bounds.length === 1 && bound.pattern.kind === "Name") {
|
|
1596
1810
|
const name = bound.pattern.name;
|
|
1597
1811
|
const set = getEvaluator(bound.set, environment);
|
|
@@ -1717,8 +1931,14 @@ export const getFunctionBuilder = (
|
|
|
1717
1931
|
return markLambdaFunction(functionValue);
|
|
1718
1932
|
}
|
|
1719
1933
|
const pairs: [Value, Value][] = [];
|
|
1720
|
-
const sets = mapBoundSets(bounds, (set) =>
|
|
1721
|
-
getNormalizedElements(
|
|
1934
|
+
const sets = mapBoundSets(bounds, (set, index) =>
|
|
1935
|
+
getNormalizedElements(
|
|
1936
|
+
bounds.length > 1 && typeof domain === "object" && domain.kind === "ProductSet"
|
|
1937
|
+
? domain.factors[index]
|
|
1938
|
+
: domain,
|
|
1939
|
+
set,
|
|
1940
|
+
context.environment.runtime.version,
|
|
1941
|
+
),
|
|
1722
1942
|
);
|
|
1723
1943
|
forEachBoundElement(bounds, sets, context.scope, (scope) => {
|
|
1724
1944
|
const key =
|
|
@@ -1733,13 +1953,22 @@ export const getFunctionBuilder = (
|
|
|
1733
1953
|
const template = getLazyFunctionTemplate(bounds, expression.body);
|
|
1734
1954
|
const boundTupleLengths = getBoundTupleLengths(bounds);
|
|
1735
1955
|
const bodyNames = getScopeNames(expression.body);
|
|
1956
|
+
const coverage = environment.coverage;
|
|
1736
1957
|
const createLazy = (domain: Value, context: Context) => {
|
|
1737
1958
|
const scope = trimScope(context.scope, bodyNames);
|
|
1738
1959
|
const lambdaContext = withScope(context, scope);
|
|
1960
|
+
const compute = (argument: Value) =>
|
|
1961
|
+
body(withScope(lambdaContext, bindArgument(bounds, scope, argument)));
|
|
1962
|
+
const node = coverage && !environment.callStack ? coverage.current : -1;
|
|
1739
1963
|
const functionValue = keepLambda({
|
|
1740
1964
|
value: createLazyFunction(
|
|
1741
1965
|
domain,
|
|
1742
|
-
|
|
1966
|
+
coverage
|
|
1967
|
+
? (argument) =>
|
|
1968
|
+
coverage.current === -1
|
|
1969
|
+
? compute(argument)
|
|
1970
|
+
: runAtCoverageNode(coverage, node, () => compute(argument))
|
|
1971
|
+
: compute,
|
|
1743
1972
|
getLazyFunctionSource(template, bounds, domain),
|
|
1744
1973
|
boundTupleLengths,
|
|
1745
1974
|
),
|
|
@@ -1791,6 +2020,23 @@ const compileFunctionConstruction = (
|
|
|
1791
2020
|
): Evaluator => {
|
|
1792
2021
|
const build = getFunctionBuilder(expression, environment).build;
|
|
1793
2022
|
const bounds = expression.bounds;
|
|
2023
|
+
const coverage = environment.coverage;
|
|
2024
|
+
if (coverage) {
|
|
2025
|
+
return (context) => {
|
|
2026
|
+
const domain = getBoundsDomain(bounds, context);
|
|
2027
|
+
const value = build(domain, context);
|
|
2028
|
+
const sets =
|
|
2029
|
+
bounds.length === 1 || typeof domain !== "object" || domain.kind !== "ProductSet"
|
|
2030
|
+
? [domain]
|
|
2031
|
+
: domain.factors;
|
|
2032
|
+
const isConverted =
|
|
2033
|
+
(typeof value !== "object" || value.kind !== "LazyFunction") && sets.every(isReducibleSet);
|
|
2034
|
+
if (isConverted && coverage.current !== -1 && coverage.covered.has(expression)) {
|
|
2035
|
+
chargeFunctionConstruction(coverage, coverage.current, sets);
|
|
2036
|
+
}
|
|
2037
|
+
return value;
|
|
2038
|
+
};
|
|
2039
|
+
}
|
|
1794
2040
|
if (bounds.length === 1 && bounds[0].pattern.kind === "Name") {
|
|
1795
2041
|
const set = getEvaluator(bounds[0].set, environment);
|
|
1796
2042
|
return (context) => build(set(context), context);
|
|
@@ -1864,29 +2110,19 @@ export const getLazyFilter = (
|
|
|
1864
2110
|
) => {
|
|
1865
2111
|
const predicate = getEvaluator(expression.predicate, environment);
|
|
1866
2112
|
const pattern = expression.bound.pattern;
|
|
1867
|
-
const
|
|
1868
|
-
const source = range && {
|
|
2113
|
+
const predicateNode = describeNode(expression.predicate);
|
|
2114
|
+
const source = expression.predicate.location.range && {
|
|
1869
2115
|
names: pattern.kind === "Name" ? pattern.name : pattern.names.join(", "),
|
|
1870
|
-
predicate:
|
|
2116
|
+
predicate: predicateNode,
|
|
1871
2117
|
};
|
|
1872
|
-
const predicateNode = describeNode(expression.predicate);
|
|
1873
2118
|
const coverage = environment.coverage;
|
|
1874
|
-
const testCovered = (node: number, isMember: boolean, test: () => Value) => {
|
|
1875
|
-
if (!coverage || node === -1) return test();
|
|
1876
|
-
if (!isMember) coverage.secondary[node]++;
|
|
1877
|
-
const value = runAtCoverageNode(coverage, isMember ? -1 : node, test);
|
|
1878
|
-
if (!isMember && value === true) coverage.secondary[node]++;
|
|
1879
|
-
return value;
|
|
1880
|
-
};
|
|
1881
2119
|
const createFiltered = (
|
|
1882
2120
|
base: Value,
|
|
1883
2121
|
context: Context,
|
|
1884
2122
|
evaluator: Evaluator,
|
|
1885
2123
|
node: number,
|
|
1886
|
-
): RebindableFilteredSet =>
|
|
1887
|
-
|
|
1888
|
-
base,
|
|
1889
|
-
test: (element, isMember) => {
|
|
2124
|
+
): RebindableFilteredSet => {
|
|
2125
|
+
const test = (element: Value, isMember: boolean) => {
|
|
1890
2126
|
if (
|
|
1891
2127
|
pattern.kind === "Tuple" &&
|
|
1892
2128
|
getSequenceElements(element)?.length !== pattern.names.length
|
|
@@ -1895,29 +2131,60 @@ export const getLazyFilter = (
|
|
|
1895
2131
|
`Attempted to check if the value:\n${prettyPrint(formatValue(element))}\nis an element of a set of ${pattern.names.length}-tuples.`,
|
|
1896
2132
|
);
|
|
1897
2133
|
}
|
|
1898
|
-
const value =
|
|
1899
|
-
evaluator(withScope(context, bindPattern(context.scope, pattern, element))),
|
|
1900
|
-
);
|
|
2134
|
+
const value = evaluator(withScope(context, bindPattern(context.scope, pattern, element)));
|
|
1901
2135
|
if (typeof value !== "boolean") {
|
|
1902
2136
|
throw new TlaEvaluationError(
|
|
1903
2137
|
`${isMember ? "The evaluation of predicate" : "Evaluating predicate"} ${predicateNode} yielded non-Boolean value.`,
|
|
1904
2138
|
);
|
|
1905
2139
|
}
|
|
1906
2140
|
return value;
|
|
1907
|
-
}
|
|
1908
|
-
|
|
1909
|
-
rebind: (tracing) =>
|
|
2141
|
+
};
|
|
2142
|
+
const rebind = (tracing: Environment) =>
|
|
1910
2143
|
createFiltered(
|
|
1911
2144
|
base,
|
|
1912
2145
|
{ ...context, environment: tracing },
|
|
1913
2146
|
getEvaluator(expression.predicate, tracing),
|
|
1914
2147
|
-1,
|
|
1915
|
-
)
|
|
1916
|
-
|
|
2148
|
+
);
|
|
2149
|
+
if (!coverage || node === -1) return { kind: "FilteredSet", base, test, source, rebind };
|
|
2150
|
+
return {
|
|
2151
|
+
kind: "FilteredSet",
|
|
2152
|
+
base,
|
|
2153
|
+
test: (element, isMember) =>
|
|
2154
|
+
runAtCoverageNode(coverage, isMember ? -1 : node, () => test(element, isMember)),
|
|
2155
|
+
startPass: (isMaterialized) => {
|
|
2156
|
+
const draws = createProductSetEnumerator(coverage, base);
|
|
2157
|
+
return (element) => {
|
|
2158
|
+
draws?.next();
|
|
2159
|
+
tagSubset(coverage, base, element);
|
|
2160
|
+
coverage.secondary[node]++;
|
|
2161
|
+
const value = runAtCoverageNode(coverage, node, () => test(element, false));
|
|
2162
|
+
if (isMaterialized && value) coverage.secondary[node]++;
|
|
2163
|
+
return value;
|
|
2164
|
+
};
|
|
2165
|
+
},
|
|
2166
|
+
source,
|
|
2167
|
+
rebind,
|
|
2168
|
+
};
|
|
2169
|
+
};
|
|
1917
2170
|
return (base: Value, context: Context, node = -1) =>
|
|
1918
2171
|
createFiltered(base, context, predicate, node);
|
|
1919
2172
|
};
|
|
1920
2173
|
|
|
2174
|
+
const hasLocalName = (expression: Expression): boolean =>
|
|
2175
|
+
isLocallyResolved(expression) ||
|
|
2176
|
+
expression.kind === "OperatorReference" ||
|
|
2177
|
+
getChildren(expression).some(hasLocalName);
|
|
2178
|
+
|
|
2179
|
+
export const isUniformPredicate = (
|
|
2180
|
+
expression: Expression & { kind: "SetFilter" },
|
|
2181
|
+
environment: Environment,
|
|
2182
|
+
) =>
|
|
2183
|
+
expression.bound.pattern.kind === "Name" &&
|
|
2184
|
+
!environment.coverage &&
|
|
2185
|
+
!hasLocalName(expression.predicate) &&
|
|
2186
|
+
!isExpressionImpure([expression.predicate], environment, "varying");
|
|
2187
|
+
|
|
1921
2188
|
export const expectFilterPredicate = (
|
|
1922
2189
|
value: Value,
|
|
1923
2190
|
expression: Expression & { kind: "SetFilter" },
|
|
@@ -1960,32 +2227,34 @@ const compileSetComprehension = (
|
|
|
1960
2227
|
const filterLazily = getLazyFilter(expression, environment);
|
|
1961
2228
|
const pattern = expression.bound.pattern;
|
|
1962
2229
|
const coverage = environment.coverage;
|
|
2230
|
+
const isUniform = isUniformPredicate(expression, environment);
|
|
1963
2231
|
return (context) => {
|
|
1964
2232
|
const base = set(context);
|
|
1965
2233
|
if (!isReducibleSet(base)) return filterLazily(base, context, coverage?.current);
|
|
1966
2234
|
const kept: Value[] = [];
|
|
1967
|
-
const
|
|
2235
|
+
const elements = base.kind === "Interval" ? base : toFiniteSet(base).elements;
|
|
2236
|
+
const size = Array.isArray(elements) ? elements.length : elements.high - elements.low + 1;
|
|
2237
|
+
for (let position = 0; position < size; position++) {
|
|
2238
|
+
const element = Array.isArray(elements) ? elements[position] : elements.low + position;
|
|
1968
2239
|
const value = predicate(withScope(context, bindPattern(context.scope, pattern, element)));
|
|
1969
2240
|
if (expectFilterPredicate(value, expression)) addBoundedElement(kept, element);
|
|
1970
|
-
|
|
1971
|
-
const elements = base.kind === "Interval" ? base : toFiniteSet(base).elements;
|
|
1972
|
-
forEachElement(elements, visit);
|
|
1973
|
-
if (coverage && coverage.current !== -1) {
|
|
1974
|
-
coverage.secondary[coverage.current] +=
|
|
1975
|
-
(Array.isArray(elements) ? elements.length : elements.high - elements.low + 1) +
|
|
1976
|
-
kept.length;
|
|
2241
|
+
else if (isUniform) break;
|
|
1977
2242
|
}
|
|
2243
|
+
if (coverage) costCoverage(coverage, base, size + 1);
|
|
1978
2244
|
return createNormalizedSet(kept);
|
|
1979
2245
|
};
|
|
1980
2246
|
}
|
|
1981
2247
|
if (expression.kind === "SetMap") {
|
|
1982
2248
|
const mapped = getEvaluator(expression.expression, environment);
|
|
2249
|
+
const coverage = environment.coverage;
|
|
1983
2250
|
return (context) => {
|
|
1984
2251
|
const elements: Value[] = [];
|
|
1985
|
-
|
|
2252
|
+
const add = (scope: Scope | undefined) => {
|
|
1986
2253
|
addBoundedElement(elements, mapped(withScope(context, scope)));
|
|
1987
2254
|
return false;
|
|
1988
|
-
}
|
|
2255
|
+
};
|
|
2256
|
+
if (coverage) forEachChargedBinding(expression.bounds, context, coverage, add);
|
|
2257
|
+
else forEachBinding(expression.bounds, context, add);
|
|
1989
2258
|
return createEnumeratedSet(elements);
|
|
1990
2259
|
};
|
|
1991
2260
|
}
|
|
@@ -1999,16 +2268,15 @@ const compileSetComprehension = (
|
|
|
1999
2268
|
}
|
|
2000
2269
|
const body = getEvaluator(expression.body, environment);
|
|
2001
2270
|
const evaluateSet = getEvaluator(set, environment);
|
|
2271
|
+
const coverage = environment.coverage;
|
|
2002
2272
|
return (context) => {
|
|
2003
|
-
const
|
|
2004
|
-
|
|
2005
|
-
|
|
2006
|
-
set,
|
|
2007
|
-
context.environment.runtime.version,
|
|
2008
|
-
);
|
|
2273
|
+
const base = evaluateSet(context);
|
|
2274
|
+
const elements = getChoiceElements(base, expression, set, context.environment.runtime.version);
|
|
2275
|
+
const enumerator = coverage && createChargedEnumerator(coverage, base, elements, true);
|
|
2009
2276
|
let chosen: Value | undefined;
|
|
2010
2277
|
const pattern = expression.pattern;
|
|
2011
2278
|
someElement(elements, (element) => {
|
|
2279
|
+
enumerator?.next();
|
|
2012
2280
|
if (
|
|
2013
2281
|
pattern.kind === "Tuple" &&
|
|
2014
2282
|
getSequenceElements(element)?.length !== pattern.names.length
|
|
@@ -2022,8 +2290,9 @@ const compileSetComprehension = (
|
|
|
2022
2290
|
chosen = getBoundValue(pattern, scope);
|
|
2023
2291
|
return true;
|
|
2024
2292
|
});
|
|
2025
|
-
if (chosen
|
|
2026
|
-
|
|
2293
|
+
if (chosen !== undefined) return chosen;
|
|
2294
|
+
enumerator?.next();
|
|
2295
|
+
throw createNoChoiceError(expression);
|
|
2027
2296
|
};
|
|
2028
2297
|
};
|
|
2029
2298
|
|
|
@@ -2035,20 +2304,21 @@ export const hasDuplicateFields = (sortedFields: RecordField[]) =>
|
|
|
2035
2304
|
|
|
2036
2305
|
const compileRecord = (recordFields: RecordField[], environment: Environment): Evaluator => {
|
|
2037
2306
|
const fields = getSortedFields(recordFields);
|
|
2038
|
-
const
|
|
2039
|
-
|
|
2040
|
-
if (hasDuplicates) {
|
|
2307
|
+
const values = recordFields.map((field) => getEvaluator(field.value, environment));
|
|
2308
|
+
if (hasDuplicateFields(fields)) {
|
|
2041
2309
|
return (context) =>
|
|
2042
2310
|
createRecord(
|
|
2043
|
-
|
|
2311
|
+
recordFields.map((field, index): [string, Value] => [field.name, values[index](context)]),
|
|
2044
2312
|
);
|
|
2045
2313
|
}
|
|
2046
2314
|
const names = fields.map((field) => field.name);
|
|
2047
2315
|
const writtenNames = recordFields.map((field) => field.name);
|
|
2048
2316
|
if (writtenNames.some((name, index) => name !== names[index])) {
|
|
2317
|
+
const writtenIndexes = fields.map((field) => recordFields.indexOf(field));
|
|
2049
2318
|
return (context) =>
|
|
2050
2319
|
createWrittenRecord(
|
|
2051
2320
|
names,
|
|
2321
|
+
writtenIndexes,
|
|
2052
2322
|
values.map((value) => value(context)),
|
|
2053
2323
|
writtenNames,
|
|
2054
2324
|
);
|
|
@@ -2098,25 +2368,31 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2098
2368
|
};
|
|
2099
2369
|
case "And": {
|
|
2100
2370
|
const operands = expression.operands.map(getChildEvaluator);
|
|
2101
|
-
return (
|
|
2102
|
-
|
|
2103
|
-
|
|
2104
|
-
|
|
2105
|
-
|
|
2106
|
-
|
|
2107
|
-
|
|
2108
|
-
|
|
2371
|
+
return (
|
|
2372
|
+
compileTracedJunction(expression, operands, environment.callStack) ??
|
|
2373
|
+
((context) => {
|
|
2374
|
+
for (let index = 0; index < operands.length; index++) {
|
|
2375
|
+
const value = operands[index](context);
|
|
2376
|
+
if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
|
|
2377
|
+
if (!value) return false;
|
|
2378
|
+
}
|
|
2379
|
+
return true;
|
|
2380
|
+
})
|
|
2381
|
+
);
|
|
2109
2382
|
}
|
|
2110
2383
|
case "Or": {
|
|
2111
2384
|
const operands = expression.operands.map(getChildEvaluator);
|
|
2112
|
-
return (
|
|
2113
|
-
|
|
2114
|
-
|
|
2115
|
-
|
|
2116
|
-
|
|
2117
|
-
|
|
2118
|
-
|
|
2119
|
-
|
|
2385
|
+
return (
|
|
2386
|
+
compileTracedJunction(expression, operands, environment.callStack) ??
|
|
2387
|
+
((context) => {
|
|
2388
|
+
for (let index = 0; index < operands.length; index++) {
|
|
2389
|
+
const value = operands[index](context);
|
|
2390
|
+
if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
|
|
2391
|
+
if (value) return true;
|
|
2392
|
+
}
|
|
2393
|
+
return false;
|
|
2394
|
+
})
|
|
2395
|
+
);
|
|
2120
2396
|
}
|
|
2121
2397
|
case "Prime": {
|
|
2122
2398
|
const inner = getChildEvaluator(expression.expression);
|
|
@@ -2202,8 +2478,19 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2202
2478
|
case "RecordSet": {
|
|
2203
2479
|
const fields = getSortedFields(expression.fields);
|
|
2204
2480
|
const names = fields.map((field) => field.name);
|
|
2205
|
-
const
|
|
2206
|
-
|
|
2481
|
+
const writtenIndexes = fields.map((field) => expression.fields.indexOf(field));
|
|
2482
|
+
const sets = expression.fields.map((field) => getChildEvaluator(field.value));
|
|
2483
|
+
if (writtenIndexes.every((writtenIndex, index) => writtenIndex === index)) {
|
|
2484
|
+
return (context) => ({ kind: "RecordSet", names, sets: sets.map((set) => set(context)) });
|
|
2485
|
+
}
|
|
2486
|
+
return (context) => {
|
|
2487
|
+
const writtenSets = sets.map((set) => set(context));
|
|
2488
|
+
return {
|
|
2489
|
+
kind: "RecordSet",
|
|
2490
|
+
names,
|
|
2491
|
+
sets: writtenIndexes.map((index) => writtenSets[index]),
|
|
2492
|
+
};
|
|
2493
|
+
};
|
|
2207
2494
|
}
|
|
2208
2495
|
case "Except":
|
|
2209
2496
|
return compileExcept(expression, environment);
|
|
@@ -2270,6 +2557,8 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2270
2557
|
}
|
|
2271
2558
|
case "Label":
|
|
2272
2559
|
return getChildEvaluator(expression.body);
|
|
2560
|
+
case "Selection":
|
|
2561
|
+
return getChildEvaluator(expression.expression);
|
|
2273
2562
|
case "Subexpression":
|
|
2274
2563
|
return () => {
|
|
2275
2564
|
throw new TlaEvaluationError(
|