tla-ts 0.0.10-dev.d618a2d79 → 0.0.10-dev.e3e5dd576
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 +49 -44
- package/dist/transfer.js +48 -43
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +14 -2
- package/src/bags.ts +50 -29
- package/src/builtins.ts +4 -3
- package/src/check-failure.ts +13 -11
- package/src/check-trace.ts +116 -64
- package/src/check.ts +516 -280
- 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 +190 -1
- package/src/dependencies.ts +68 -15
- package/src/dfid.ts +101 -36
- package/src/environment.ts +123 -38
- package/src/errors.ts +7 -0
- package/src/evaluate.ts +370 -99
- package/src/exit-codes.ts +28 -14
- package/src/instances.ts +135 -11
- 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 +51 -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/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 +27 -1
- 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/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 +1 -2
- 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 +1 -2
- package/src/prover/smt/solver/dt2bv-tactic.ts +57 -21
- 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 +5 -8
- 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 +1 -2
- 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/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/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 +1 -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/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/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/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/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 +65 -12
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +129 -43
- 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 +17 -7
- package/src/prover/smt/solver/sat/sat2goal.ts +72 -48
- 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 +713 -210
- package/src/prover/smt/solver/solve-eqs.ts +36 -37
- package/src/prover/smt/solver/solver.ts +18 -3
- package/src/prover/smt/solver/tactic.ts +350 -195
- 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 +11 -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 +1 -0
- 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 +1274 -257
- package/src/runtime.ts +7 -1
- 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 +18 -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 +11 -6
- package/src/sany/xml.ts +2 -3
- package/src/search.ts +319 -135
- package/src/simulate.ts +235 -182
- package/src/spec-description.ts +8 -6
- package/src/standard-definitions.ts +1 -0
- package/src/standard-modules.ts +56 -22
- package/src/subexpressions.ts +564 -138
- package/src/successors.ts +37 -13
- 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 +67 -43
- 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/lexer.ts
CHANGED
|
@@ -1,4 +1,5 @@
|
|
|
1
1
|
import { TlaSyntaxError } from "./errors";
|
|
2
|
+
import { getEndOfFile } from "./sany/lexer";
|
|
2
3
|
|
|
3
4
|
type TokenKind =
|
|
4
5
|
| "Identifier"
|
|
@@ -479,8 +480,17 @@ export const matchBasedNumber = (source: string, index: number, isTlapm = false)
|
|
|
479
480
|
|
|
480
481
|
export const tokenize = (source: string, isTlapm = false): Token[] => {
|
|
481
482
|
const headerMatch = MODULE_HEADER.exec(source);
|
|
482
|
-
if (!headerMatch)
|
|
483
|
-
|
|
483
|
+
if (!headerMatch) {
|
|
484
|
+
// SANY skips the text before a module header, so it fails at the end of the file.
|
|
485
|
+
const end = getEndOfFile(source);
|
|
486
|
+
const reason = "Expected a module header such as ---- MODULE Name ----";
|
|
487
|
+
throw new TlaSyntaxError(`${reason} at line ${end.line}, column ${end.column}`, undefined, {
|
|
488
|
+
reason,
|
|
489
|
+
line: end.line,
|
|
490
|
+
column: end.column,
|
|
491
|
+
isEnd: true,
|
|
492
|
+
});
|
|
493
|
+
}
|
|
484
494
|
const tokens: Token[] = [];
|
|
485
495
|
// Each name is one string object, so looking a name up in a scope compares pointers.
|
|
486
496
|
const names = new Map<string, string>();
|
package/src/liveness-checker.ts
CHANGED
|
@@ -22,6 +22,7 @@ import {
|
|
|
22
22
|
type Solution,
|
|
23
23
|
type Tableau,
|
|
24
24
|
} from "./tableau";
|
|
25
|
+
import { findTraceLasso, type TraceLasso } from "./trace-liveness";
|
|
25
26
|
import { isSameValue, type Value } from "./values";
|
|
26
27
|
|
|
27
28
|
export interface LiveSuccessor<State = Value[]> {
|
|
@@ -46,10 +47,21 @@ export interface LivenessChecker {
|
|
|
46
47
|
tracing?: Environment,
|
|
47
48
|
) => number[] | undefined;
|
|
48
49
|
storeState: (pending: number, index: number) => void;
|
|
50
|
+
getStateCounts: () => number[];
|
|
49
51
|
findViolation: () => Lasso | undefined;
|
|
50
52
|
getViolatedProperties: (path: Value[][], cycleStart: number) => string[];
|
|
51
53
|
}
|
|
52
54
|
|
|
55
|
+
export interface TraceViolation extends TraceLasso {
|
|
56
|
+
properties: string[];
|
|
57
|
+
failures: TlaEvaluationError[];
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
export interface LivenessChecks {
|
|
61
|
+
solutions: Solution[];
|
|
62
|
+
findTraceViolation: (trace: Value[][], fingerprints: bigint[]) => TraceViolation | undefined;
|
|
63
|
+
}
|
|
64
|
+
|
|
53
65
|
export interface LiveGraph<State> {
|
|
54
66
|
branches: number;
|
|
55
67
|
addInitialState: (index: number, state: State) => void;
|
|
@@ -58,14 +70,26 @@ export interface LiveGraph<State> {
|
|
|
58
70
|
index: number,
|
|
59
71
|
state: State,
|
|
60
72
|
successors: LiveSuccessor<State>[],
|
|
73
|
+
isRerun?: boolean,
|
|
61
74
|
) => number[] | undefined;
|
|
62
75
|
storeState: (pending: number, index: number) => void;
|
|
76
|
+
getStateCounts: () => number[];
|
|
63
77
|
findViolation: () => Lasso | undefined;
|
|
64
78
|
}
|
|
65
79
|
|
|
66
80
|
export interface SearchGraph<State> {
|
|
67
81
|
getFingerprint: (successor: LiveSuccessor<State>) => number;
|
|
68
|
-
|
|
82
|
+
forEachActionSuccessors: (
|
|
83
|
+
index: number,
|
|
84
|
+
state: State,
|
|
85
|
+
onSuccessors: (successors: LiveSuccessor<State>[]) => void,
|
|
86
|
+
replay?: Environment,
|
|
87
|
+
) => void;
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
interface Tracing {
|
|
91
|
+
atoms: LiveAtoms<Value[]>;
|
|
92
|
+
replay: Environment | undefined;
|
|
69
93
|
}
|
|
70
94
|
|
|
71
95
|
export interface LiveEvaluation<State> {
|
|
@@ -116,6 +140,7 @@ interface BehaviorGraph<State> {
|
|
|
116
140
|
nextSiblings: number[];
|
|
117
141
|
nodeIds: NodeTable;
|
|
118
142
|
isDone: boolean[];
|
|
143
|
+
stateCount: number;
|
|
119
144
|
errorNode: number | undefined;
|
|
120
145
|
}
|
|
121
146
|
|
|
@@ -248,13 +273,14 @@ const getLiveFormula = (
|
|
|
248
273
|
const fairness = temporals.map((item) =>
|
|
249
274
|
toLiveExpression(item.expression, item.scope, environment),
|
|
250
275
|
);
|
|
251
|
-
const
|
|
252
|
-
|
|
276
|
+
const checks = properties.map((property) =>
|
|
277
|
+
toLiveExpression(property.expression, property.scope, environment),
|
|
253
278
|
);
|
|
279
|
+
const negations = checks.map((check) => createUnary("Not", check));
|
|
254
280
|
const violation = negations.length === 1 ? negations[0] : createJunction("Or", negations);
|
|
255
281
|
const formula =
|
|
256
282
|
fairness.length === 0 ? violation : createJunction("And", [...fairness, violation]);
|
|
257
|
-
return { formula,
|
|
283
|
+
return { formula, checks };
|
|
258
284
|
};
|
|
259
285
|
|
|
260
286
|
export type LiveAtom = LiveState | LiveEnabled | LiveAction;
|
|
@@ -309,28 +335,83 @@ export const getLiveExpressions = (solutions: Solution[]) =>
|
|
|
309
335
|
getAtomExpressions(atom).map((item) => item.expression),
|
|
310
336
|
);
|
|
311
337
|
|
|
312
|
-
|
|
313
|
-
properties: TemporalProperty[],
|
|
314
|
-
temporals: ScopedExpression[],
|
|
315
|
-
environment: Environment,
|
|
316
|
-
search: SearchGraph<Value[]>,
|
|
317
|
-
): LivenessChecker | undefined => {
|
|
318
|
-
if (properties.length === 0) return undefined;
|
|
319
|
-
const live = getLiveFormula(properties, temporals, environment);
|
|
320
|
-
// A check evaluated once for a state shows what TLC shows when no check repeats an effect. A
|
|
321
|
-
// definition TLC evaluates as it starts repeats nothing, but a scope can bind any definition.
|
|
338
|
+
const isSharingResults = (formula: LiveExpression, environment: Environment) => {
|
|
322
339
|
const formulaAtoms = new Set<LiveAtom>();
|
|
323
|
-
collectAtoms(
|
|
340
|
+
collectAtoms(formula, formulaAtoms);
|
|
324
341
|
const checked = [...formulaAtoms].flatMap(getAtomExpressions);
|
|
325
|
-
|
|
342
|
+
return checked.every((item) => item.scope === undefined)
|
|
326
343
|
? !isExpressionImpure(
|
|
327
344
|
checked.map((item) => item.expression),
|
|
328
345
|
environment,
|
|
329
346
|
"repeated",
|
|
330
347
|
)
|
|
331
348
|
: !hasRepeatedEffects(environment);
|
|
332
|
-
|
|
349
|
+
};
|
|
350
|
+
|
|
351
|
+
const getViolatedProperties = (
|
|
352
|
+
properties: TemporalProperty[],
|
|
353
|
+
checks: LiveExpression[],
|
|
354
|
+
path: Value[][],
|
|
355
|
+
cycleStart: number,
|
|
356
|
+
environment: Environment,
|
|
357
|
+
failures?: TlaEvaluationError[],
|
|
358
|
+
) => [
|
|
359
|
+
...new Set(
|
|
360
|
+
properties
|
|
361
|
+
.filter((_property, position) => {
|
|
362
|
+
try {
|
|
363
|
+
return !evaluateOnLasso(checks[position], path, cycleStart, 0, environment);
|
|
364
|
+
} catch (error) {
|
|
365
|
+
if (!failures || !(error instanceof TlaEvaluationError)) throw error;
|
|
366
|
+
failures.push(error);
|
|
367
|
+
return false;
|
|
368
|
+
}
|
|
369
|
+
})
|
|
370
|
+
.map((property) => property.name),
|
|
371
|
+
),
|
|
372
|
+
];
|
|
373
|
+
|
|
374
|
+
export const createLivenessChecks = (
|
|
375
|
+
properties: TemporalProperty[],
|
|
376
|
+
temporals: ScopedExpression[],
|
|
377
|
+
environment: Environment,
|
|
378
|
+
): LivenessChecks | undefined => {
|
|
379
|
+
if (properties.length === 0) return undefined;
|
|
380
|
+
const live = getLiveFormula(properties, temporals, environment);
|
|
333
381
|
const solutions = getSolutions(live.formula);
|
|
382
|
+
const atoms = getInterpretedAtoms(environment);
|
|
383
|
+
const isShared = isSharingResults(live.formula, environment);
|
|
384
|
+
return {
|
|
385
|
+
solutions,
|
|
386
|
+
findTraceViolation: (trace, fingerprints) => {
|
|
387
|
+
const lasso = findTraceLasso(trace, fingerprints, solutions, atoms, isShared);
|
|
388
|
+
if (!lasso) return undefined;
|
|
389
|
+
// Liveness#findViolatedProperties reports a property it fails to evaluate on the lasso and goes on.
|
|
390
|
+
const failures: TlaEvaluationError[] = [];
|
|
391
|
+
const violated = getViolatedProperties(
|
|
392
|
+
properties,
|
|
393
|
+
live.checks,
|
|
394
|
+
lasso.positions.map((position) => trace[position]),
|
|
395
|
+
lasso.cyclePosition - 1,
|
|
396
|
+
environment,
|
|
397
|
+
failures,
|
|
398
|
+
);
|
|
399
|
+
return { ...lasso, properties: violated, failures };
|
|
400
|
+
},
|
|
401
|
+
};
|
|
402
|
+
};
|
|
403
|
+
|
|
404
|
+
export const createLivenessChecker = (
|
|
405
|
+
properties: TemporalProperty[],
|
|
406
|
+
temporals: ScopedExpression[],
|
|
407
|
+
environment: Environment,
|
|
408
|
+
search: SearchGraph<Value[]>,
|
|
409
|
+
): LivenessChecker | undefined => {
|
|
410
|
+
if (properties.length === 0) return undefined;
|
|
411
|
+
const live = getLiveFormula(properties, temporals, environment);
|
|
412
|
+
const isShared = isSharingResults(live.formula, environment);
|
|
413
|
+
const solutions = getSolutions(live.formula);
|
|
414
|
+
const tracing: Tracing = { atoms: getInterpretedAtoms(environment), replay: undefined };
|
|
334
415
|
const graph = createLiveGraph(
|
|
335
416
|
solutions,
|
|
336
417
|
{
|
|
@@ -349,16 +430,22 @@ export const createLivenessChecker = (
|
|
|
349
430
|
}
|
|
350
431
|
},
|
|
351
432
|
},
|
|
352
|
-
|
|
433
|
+
{
|
|
434
|
+
getFingerprint: search.getFingerprint,
|
|
435
|
+
forEachActionSuccessors: (index, state, onSuccessors) =>
|
|
436
|
+
search.forEachActionSuccessors(index, state, onSuccessors, tracing.replay),
|
|
437
|
+
},
|
|
353
438
|
environment.runtime.version !== "1.7.4",
|
|
354
439
|
);
|
|
355
440
|
const traceWith = <Result>(replay: Environment | undefined, run: () => Result) => {
|
|
356
441
|
if (replay === undefined) return run();
|
|
357
442
|
tracing.atoms = getInterpretedAtoms(replay);
|
|
443
|
+
tracing.replay = replay;
|
|
358
444
|
try {
|
|
359
445
|
return run();
|
|
360
446
|
} finally {
|
|
361
447
|
tracing.atoms = getInterpretedAtoms(environment);
|
|
448
|
+
tracing.replay = undefined;
|
|
362
449
|
}
|
|
363
450
|
};
|
|
364
451
|
return {
|
|
@@ -367,19 +454,12 @@ export const createLivenessChecker = (
|
|
|
367
454
|
addInitialState: (index, state, replay) =>
|
|
368
455
|
traceWith(replay, () => graph.addInitialState(index, state)),
|
|
369
456
|
addState: (index, state, successors, replay) =>
|
|
370
|
-
traceWith(replay, () => graph.addState(index, state, successors)),
|
|
457
|
+
traceWith(replay, () => graph.addState(index, state, successors, replay !== undefined)),
|
|
371
458
|
storeState: graph.storeState,
|
|
459
|
+
getStateCounts: graph.getStateCounts,
|
|
372
460
|
findViolation: graph.findViolation,
|
|
373
|
-
getViolatedProperties: (path, cycleStart) =>
|
|
374
|
-
|
|
375
|
-
properties
|
|
376
|
-
.filter(
|
|
377
|
-
(_property, position) =>
|
|
378
|
-
!evaluateOnLasso(live.negations[position].body, path, cycleStart, 0, environment),
|
|
379
|
-
)
|
|
380
|
-
.map((property) => property.name),
|
|
381
|
-
),
|
|
382
|
-
],
|
|
461
|
+
getViolatedProperties: (path, cycleStart) =>
|
|
462
|
+
getViolatedProperties(properties, live.checks, path, cycleStart, environment),
|
|
383
463
|
};
|
|
384
464
|
};
|
|
385
465
|
|
|
@@ -508,6 +588,7 @@ export const createLiveGraph = <State>(
|
|
|
508
588
|
nextSiblings: [],
|
|
509
589
|
nodeIds: { slots: new Int32Array(3 << 10), size: 0, shift: 22 },
|
|
510
590
|
isDone: [],
|
|
591
|
+
stateCount: 0,
|
|
511
592
|
errorNode: undefined,
|
|
512
593
|
}));
|
|
513
594
|
const checkState = (
|
|
@@ -631,8 +712,16 @@ export const createLiveGraph = <State>(
|
|
|
631
712
|
writeToPool(behavior.lastNodes, state, [node]);
|
|
632
713
|
return node;
|
|
633
714
|
};
|
|
634
|
-
const
|
|
635
|
-
|
|
715
|
+
const hasState = (behavior: BehaviorGraph<State>, state: number) =>
|
|
716
|
+
state < 0
|
|
717
|
+
? behavior.checks.nodes.some(
|
|
718
|
+
(_checks, tableauNode) => getNodeId(behavior, state, tableauNode) !== undefined,
|
|
719
|
+
)
|
|
720
|
+
: behavior.isDone[state] === true || (behavior.firstNodes.data[state] ?? NO_NODE) !== NO_NODE;
|
|
721
|
+
const recordNode = (behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
|
|
722
|
+
if (!hasState(behavior, state)) behavior.stateCount++;
|
|
723
|
+
return linkNode(behavior, state, tableauNode, pushNode(behavior, state, tableauNode));
|
|
724
|
+
};
|
|
636
725
|
// The action results of the edge to each target are at its position in actions.
|
|
637
726
|
const writeNode = (
|
|
638
727
|
behavior: BehaviorGraph<State>,
|
|
@@ -741,39 +830,57 @@ export const createLiveGraph = <State>(
|
|
|
741
830
|
actions.push(0);
|
|
742
831
|
if (existing === undefined) expandLate(behavior, tableau, state, index, target, row, offset);
|
|
743
832
|
}
|
|
744
|
-
const nextStates = search.getSuccessors(index, state);
|
|
745
833
|
// The results of the step to the state itself come first, then those of each successor.
|
|
746
|
-
const
|
|
747
|
-
|
|
748
|
-
|
|
749
|
-
|
|
750
|
-
const
|
|
751
|
-
|
|
752
|
-
|
|
753
|
-
|
|
754
|
-
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
|
|
758
|
-
|
|
759
|
-
|
|
760
|
-
|
|
761
|
-
|
|
762
|
-
|
|
763
|
-
|
|
764
|
-
|
|
765
|
-
|
|
766
|
-
|
|
767
|
-
|
|
768
|
-
const
|
|
769
|
-
|
|
770
|
-
|
|
771
|
-
|
|
772
|
-
|
|
834
|
+
const actionBatches = [selfResults];
|
|
835
|
+
let stepCount = 1;
|
|
836
|
+
search.forEachActionSuccessors(index, state, (nextStates) => {
|
|
837
|
+
const edges = createEdgeRows(nextStates.length);
|
|
838
|
+
const results = new Uint8Array(nextStates.length * actionCount);
|
|
839
|
+
actionBatches.push(results);
|
|
840
|
+
for (let position = 0; position < nextStates.length; position++) {
|
|
841
|
+
const successor = nextStates[position];
|
|
842
|
+
const successorRow = createRows(1);
|
|
843
|
+
checkAction(
|
|
844
|
+
behavior,
|
|
845
|
+
index,
|
|
846
|
+
state,
|
|
847
|
+
row,
|
|
848
|
+
offset,
|
|
849
|
+
successor.state,
|
|
850
|
+
edges,
|
|
851
|
+
position * actionIds.size,
|
|
852
|
+
results,
|
|
853
|
+
position * actionCount,
|
|
854
|
+
);
|
|
855
|
+
const isDone = behavior.isDone[successor.index] === true;
|
|
856
|
+
for (const next of tableauNode.successors) {
|
|
857
|
+
if (!isConsistent(behavior, next, index, successor.state, successorRow, 0)) continue;
|
|
858
|
+
const existing = getNodeId(behavior, successor.index, next);
|
|
859
|
+
if (existing !== undefined && successors.includes(existing)) continue;
|
|
860
|
+
const target = existing ?? recordNode(behavior, successor.index, next);
|
|
861
|
+
successors.push(target);
|
|
862
|
+
actions.push(stepCount + position);
|
|
863
|
+
if (existing === undefined && isDone) {
|
|
864
|
+
expandLate(
|
|
865
|
+
behavior,
|
|
866
|
+
tableau,
|
|
867
|
+
successor.state,
|
|
868
|
+
successor.index,
|
|
869
|
+
target,
|
|
870
|
+
successorRow,
|
|
871
|
+
0,
|
|
872
|
+
);
|
|
873
|
+
}
|
|
773
874
|
}
|
|
774
875
|
}
|
|
876
|
+
stepCount += nextStates.length;
|
|
775
877
|
});
|
|
776
878
|
if (successors.length > 0) {
|
|
879
|
+
const actionResults = new Uint8Array(stepCount * actionCount);
|
|
880
|
+
for (let batch = 0, resultOffset = 0; batch < actionBatches.length; batch++) {
|
|
881
|
+
actionResults.set(actionBatches[batch], resultOffset);
|
|
882
|
+
resultOffset += actionBatches[batch].length;
|
|
883
|
+
}
|
|
777
884
|
writeNode(behavior, node, successors, actionResults, actions, stateResults);
|
|
778
885
|
}
|
|
779
886
|
};
|
|
@@ -799,6 +906,7 @@ export const createLiveGraph = <State>(
|
|
|
799
906
|
}
|
|
800
907
|
}
|
|
801
908
|
});
|
|
909
|
+
if (!hasState(behavior, index)) behavior.stateCount++;
|
|
802
910
|
behavior.isDone[index] = true;
|
|
803
911
|
// TLC expands the nodes recorded before the loop, not the ones the loop records.
|
|
804
912
|
for (const node of getStateNodes(behavior, index)) {
|
|
@@ -848,6 +956,7 @@ export const createLiveGraph = <State>(
|
|
|
848
956
|
successors.push(successor.index);
|
|
849
957
|
actions.push(position);
|
|
850
958
|
});
|
|
959
|
+
if (!isWritten(behavior, index)) behavior.stateCount++;
|
|
851
960
|
writeNode(behavior, index, successors, actionResults, actions, stateResults);
|
|
852
961
|
};
|
|
853
962
|
|
|
@@ -1126,7 +1235,7 @@ export const createLiveGraph = <State>(
|
|
|
1126
1235
|
}
|
|
1127
1236
|
}
|
|
1128
1237
|
},
|
|
1129
|
-
addState: (index, state, successors) => {
|
|
1238
|
+
addState: (index, state, successors, isRerun) => {
|
|
1130
1239
|
const set = getSuccessorSet(index, state, successors);
|
|
1131
1240
|
const rows = createRows(set.length);
|
|
1132
1241
|
// The set holds the state itself, as a successor of the same index.
|
|
@@ -1151,6 +1260,15 @@ export const createLiveGraph = <State>(
|
|
|
1151
1260
|
);
|
|
1152
1261
|
const stateResults = checkState(behavior, index, state, rows, offset);
|
|
1153
1262
|
const tableau = behavior.solution.tableau;
|
|
1263
|
+
// TLC's rerun for a call stack fails an assertion, without a call stack, on a branch that has every edge of the state.
|
|
1264
|
+
if (
|
|
1265
|
+
isRerun &&
|
|
1266
|
+
(tableau
|
|
1267
|
+
? getStateNodes(behavior, index).some((node) => behavior.edgeCounts[node] > 0)
|
|
1268
|
+
: set.every((successor) => isWritten(behavior, successor.index)))
|
|
1269
|
+
) {
|
|
1270
|
+
throw new TlaEvaluationError("The behavior graph holds every edge of the state already.");
|
|
1271
|
+
}
|
|
1154
1272
|
if (!tableau) {
|
|
1155
1273
|
addPlainState(behavior, set, actionResults, stateResults, index);
|
|
1156
1274
|
continue;
|
|
@@ -1183,6 +1301,7 @@ export const createLiveGraph = <State>(
|
|
|
1183
1301
|
}
|
|
1184
1302
|
}
|
|
1185
1303
|
},
|
|
1304
|
+
getStateCounts: () => behaviors.map((behavior) => behavior.stateCount),
|
|
1186
1305
|
findViolation: () => {
|
|
1187
1306
|
for (const behavior of behaviors) {
|
|
1188
1307
|
for (const model of behavior.solution.models) {
|
package/src/liveness.ts
CHANGED
|
@@ -16,6 +16,7 @@ import {
|
|
|
16
16
|
forEachBoundElement,
|
|
17
17
|
getBoundElements,
|
|
18
18
|
getDefinition,
|
|
19
|
+
getReevaluatedDefinitions,
|
|
19
20
|
getStartupValue,
|
|
20
21
|
lookupScope,
|
|
21
22
|
resolveApplyOperator,
|
|
@@ -243,6 +244,7 @@ export const expandTemporal = (
|
|
|
243
244
|
return expression.operands.flatMap((operand) => expand(operand, scope, describeRange(operand)));
|
|
244
245
|
}
|
|
245
246
|
if (expression.kind === "Label") return expand(expression.body, scope);
|
|
247
|
+
if (expression.kind === "Selection") return expand(expression.expression, scope);
|
|
246
248
|
if (expression.kind === "Let") {
|
|
247
249
|
return expand(expression.body, bindLetDefinitions(expression, scope, environment));
|
|
248
250
|
}
|
|
@@ -323,12 +325,17 @@ export const expandTemporal = (
|
|
|
323
325
|
return [{ expression, scope, name: expansion.name, path: expansion.path }];
|
|
324
326
|
};
|
|
325
327
|
|
|
326
|
-
|
|
328
|
+
// TLC takes a formula apart through a LET without binding its definitions, so it evaluates an impure one again at each reference.
|
|
329
|
+
export const bindLetDefinitions = (
|
|
327
330
|
expression: Expression & { kind: "Let" },
|
|
328
331
|
scope: Scope | undefined,
|
|
329
332
|
environment: Environment,
|
|
330
333
|
) => {
|
|
331
|
-
const bound = bindDefinitions(
|
|
334
|
+
const bound = bindDefinitions(
|
|
335
|
+
expression.definitions,
|
|
336
|
+
getConstantContext(environment, scope),
|
|
337
|
+
getReevaluatedDefinitions(expression.definitions, environment),
|
|
338
|
+
);
|
|
332
339
|
for (let current = bound; current && current !== scope; current = current.parent) {
|
|
333
340
|
if (current.binding.kind === "Thunk") definitionThunks.add(current.binding);
|
|
334
341
|
}
|
|
@@ -488,12 +495,53 @@ export const toLiveExpression = (
|
|
|
488
495
|
return level > ACTION_LEVEL ? parts : toAtom(expression, scope, level);
|
|
489
496
|
};
|
|
490
497
|
|
|
498
|
+
// SANY parses `a /\ b /\ c` as `(a /\ b) /\ c`, so TLC takes a prefix below the temporal level as one formula.
|
|
499
|
+
const convertJunction = (
|
|
500
|
+
expression: Expression & { kind: "And" | "Or" },
|
|
501
|
+
scope: Scope | undefined,
|
|
502
|
+
) => {
|
|
503
|
+
const operands = expression.operands;
|
|
504
|
+
const range = expression.location.range;
|
|
505
|
+
const prefixEnds = expression.prefixEnds;
|
|
506
|
+
if (expression.isBulleted || !range || !prefixEnds) {
|
|
507
|
+
return toWhole(
|
|
508
|
+
expression,
|
|
509
|
+
scope,
|
|
510
|
+
createJunction(
|
|
511
|
+
expression.kind,
|
|
512
|
+
operands.map((operand) => convert(operand, scope)),
|
|
513
|
+
),
|
|
514
|
+
);
|
|
515
|
+
}
|
|
516
|
+
return operands.slice(1).reduce(
|
|
517
|
+
(prefix, operand, index) => {
|
|
518
|
+
const node =
|
|
519
|
+
index === operands.length - 2
|
|
520
|
+
? expression
|
|
521
|
+
: {
|
|
522
|
+
...expression,
|
|
523
|
+
operands: operands.slice(0, index + 2),
|
|
524
|
+
prefixEnds: prefixEnds.slice(0, index + 1),
|
|
525
|
+
location: { ...expression.location, range: { ...range, end: prefixEnds[index] } },
|
|
526
|
+
};
|
|
527
|
+
return toWhole(
|
|
528
|
+
node,
|
|
529
|
+
scope,
|
|
530
|
+
createJunction(expression.kind, [prefix, convert(operand, scope)]),
|
|
531
|
+
);
|
|
532
|
+
},
|
|
533
|
+
convert(operands[0], scope),
|
|
534
|
+
);
|
|
535
|
+
};
|
|
536
|
+
|
|
491
537
|
// These forms are translated part by part at every level; any other form below the temporal level is an atom.
|
|
492
538
|
const convert = (expression: Expression, scope: Scope | undefined): LiveExpression => {
|
|
493
539
|
const level = getLevel(expression, scope, environment);
|
|
494
540
|
switch (expression.kind) {
|
|
495
541
|
case "Label":
|
|
496
542
|
return convert(expression.body, scope);
|
|
543
|
+
case "Selection":
|
|
544
|
+
return convert(expression.expression, scope);
|
|
497
545
|
case "Let":
|
|
498
546
|
return convert(expression.body, bindLetDefinitions(expression, scope, environment));
|
|
499
547
|
case "Apply": {
|
|
@@ -512,14 +560,7 @@ export const toLiveExpression = (
|
|
|
512
560
|
}
|
|
513
561
|
case "And":
|
|
514
562
|
case "Or":
|
|
515
|
-
return
|
|
516
|
-
expression,
|
|
517
|
-
scope,
|
|
518
|
-
createJunction(
|
|
519
|
-
expression.kind,
|
|
520
|
-
expression.operands.map((operand) => convert(operand, scope)),
|
|
521
|
-
),
|
|
522
|
-
);
|
|
563
|
+
return convertJunction(expression, scope);
|
|
523
564
|
case "Forall":
|
|
524
565
|
case "Exists":
|
|
525
566
|
return convertQuantifier(expression, scope);
|
package/src/obligations/index.ts
CHANGED
|
@@ -179,7 +179,7 @@ const loadMule = (
|
|
|
179
179
|
|
|
180
180
|
const schedule = (modules: Map<string, Mule>) => {
|
|
181
181
|
const dependencies = new Map(
|
|
182
|
-
[...modules].map((
|
|
182
|
+
[...modules].map((entry) => [entry[0], getDependencies(entry[1]).dependencies]),
|
|
183
183
|
);
|
|
184
184
|
const seen = new Set<string>();
|
|
185
185
|
const order: Mule[] = [];
|
|
@@ -351,10 +351,7 @@ const instantiate = (
|
|
|
351
351
|
substitutes.set(name, at({ kind: "Opaque", name }, { location }));
|
|
352
352
|
}
|
|
353
353
|
const anonymized = new Map(
|
|
354
|
-
[...substitutes].map(([
|
|
355
|
-
name,
|
|
356
|
-
pipeline.anonymizer.expr(instanceScope, expression),
|
|
357
|
-
]),
|
|
354
|
+
[...substitutes].map((entry) => [entry[0], pipeline.anonymizer.expr(instanceScope, entry[1])]),
|
|
358
355
|
);
|
|
359
356
|
const body = substituteUnits(
|
|
360
357
|
shift((instanceScope?.size ?? 0) - (module.depth ?? 0)),
|
|
@@ -430,26 +430,26 @@ const createPrinter = (hyps: Hyp[] = [], options: PrinterOptions = {}) => {
|
|
|
430
430
|
);
|
|
431
431
|
case "Choose": {
|
|
432
432
|
const domainDoc = expression.domain && printExpr(expression.domain);
|
|
433
|
-
return withNames(context, [expression.name], (
|
|
433
|
+
return withNames(context, [expression.name], (names) =>
|
|
434
434
|
createBig(
|
|
435
435
|
domainDoc
|
|
436
436
|
? format(
|
|
437
437
|
"@[<b2>CHOOSE @[<b2>%s \\in@ %a@] :@ %a@]",
|
|
438
|
-
|
|
438
|
+
names[0],
|
|
439
439
|
domainDoc,
|
|
440
440
|
printExpr(expression.body),
|
|
441
441
|
)
|
|
442
|
-
: format("@[<b2>CHOOSE %s :@ %a@]",
|
|
442
|
+
: format("@[<b2>CHOOSE %s :@ %a@]", names[0], printExpr(expression.body)),
|
|
443
443
|
),
|
|
444
444
|
);
|
|
445
445
|
}
|
|
446
446
|
case "SetSt": {
|
|
447
447
|
const domainDoc = printExpr(expression.domain);
|
|
448
|
-
return withNames(context, [expression.name], (
|
|
448
|
+
return withNames(context, [expression.name], (names) =>
|
|
449
449
|
createAtom(
|
|
450
450
|
format(
|
|
451
451
|
"@[<b3>{@[<b2>%s \\in@ %a@] :@ %a}@]",
|
|
452
|
-
|
|
452
|
+
names[0],
|
|
453
453
|
domainDoc,
|
|
454
454
|
printExpr(expression.body),
|
|
455
455
|
),
|
|
@@ -643,6 +643,8 @@ export const createModuleConverter = (
|
|
|
643
643
|
},
|
|
644
644
|
{ location },
|
|
645
645
|
);
|
|
646
|
+
case "Selection":
|
|
647
|
+
return recurse(expression.expression);
|
|
646
648
|
case "Subexpression": {
|
|
647
649
|
const [head, ...selectors] = expression.selectors;
|
|
648
650
|
if (head.kind !== "Name") throw new TlaProofError("Unexpected subexpression reference");
|
package/src/parallel-worker.ts
CHANGED
|
@@ -41,8 +41,14 @@ const runWorker = (start: StartMessage, parent: Port) => {
|
|
|
41
41
|
);
|
|
42
42
|
const specification = created.specification;
|
|
43
43
|
const environment = specification.environment;
|
|
44
|
-
const search = createSearch(
|
|
45
|
-
|
|
44
|
+
const search = createSearch(
|
|
45
|
+
start.config,
|
|
46
|
+
environment,
|
|
47
|
+
specification.variableLocations,
|
|
48
|
+
() => created.order.getDeclarationOrder("variable"),
|
|
49
|
+
undefined,
|
|
50
|
+
[],
|
|
51
|
+
specification.runtimeInvariants,
|
|
46
52
|
);
|
|
47
53
|
const nextAction = search?.spec.next;
|
|
48
54
|
if (!search || nextAction === undefined)
|
package/src/parallel.ts
CHANGED
|
@@ -8,6 +8,7 @@ import {
|
|
|
8
8
|
} from "./check";
|
|
9
9
|
import { parseConfig, type ModelConfig } from "./config";
|
|
10
10
|
import { TlaEvaluationError } from "./errors";
|
|
11
|
+
import type { RuntimeInvariant } from "./environment";
|
|
11
12
|
import { isImpure } from "./evaluate";
|
|
12
13
|
import {
|
|
13
14
|
createSharedFingerprints,
|
|
@@ -43,6 +44,7 @@ export interface StartMessage extends Pick<
|
|
|
43
44
|
> {
|
|
44
45
|
type: "start";
|
|
45
46
|
config: ModelConfig;
|
|
47
|
+
runtimeInvariants: RuntimeInvariant[];
|
|
46
48
|
modules: [string, string | undefined][];
|
|
47
49
|
classes: [string, Uint8Array | undefined][];
|
|
48
50
|
index: number;
|
|
@@ -146,6 +148,8 @@ export const check = async (options: CheckOptions): Promise<CheckResult> => {
|
|
|
146
148
|
specification.variableLocations,
|
|
147
149
|
() => created.order.getDeclarationOrder("variable"),
|
|
148
150
|
report,
|
|
151
|
+
[],
|
|
152
|
+
specification.runtimeInvariants,
|
|
149
153
|
);
|
|
150
154
|
if (findAssumptionViolation(specification.assumptions, environment)) return fallBack();
|
|
151
155
|
if (
|
|
@@ -273,6 +277,7 @@ export const check = async (options: CheckOptions): Promise<CheckResult> => {
|
|
|
273
277
|
type: "start",
|
|
274
278
|
source: options.source,
|
|
275
279
|
config,
|
|
280
|
+
runtimeInvariants: specification.runtimeInvariants,
|
|
276
281
|
modules: [...modules],
|
|
277
282
|
classes: [...classes],
|
|
278
283
|
index,
|