occam-verify-cli 0.0.894 → 0.0.896
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/lib/conclusion.js +37 -14
- package/lib/metaConsequent.js +29 -10
- package/lib/metaSupposition.js +44 -23
- package/lib/premise.js +82 -53
- package/lib/verifier/nodes/intrinsicLevelAgainstMetaLevel.js +2 -40
- package/package.json +1 -1
- package/src/conclusion.js +54 -26
- package/src/metaConsequent.js +40 -17
- package/src/metaSupposition.js +69 -44
- package/src/premise.js +143 -109
- package/src/verifier/nodes/intrinsicLevelAgainstMetaLevel.js +0 -61
package/src/premise.js
CHANGED
|
@@ -8,7 +8,7 @@ import intrinsicLevelAgainstMetaLevelNodesVerifier from "./verifier/nodes/intrin
|
|
|
8
8
|
import { match } from "./utilities/array";
|
|
9
9
|
import { nodeAsString } from "./utilities/string";
|
|
10
10
|
import { nodeQuery, nodesQuery } from "./utilities/query";
|
|
11
|
-
import { metastatementNodeFromMetastatementString } from "./utilities/node";
|
|
11
|
+
import { statementNodeFromStatementString, metastatementNodeFromMetastatementString } from "./utilities/node";
|
|
12
12
|
|
|
13
13
|
const subproofAssertionNodeQuery = nodeQuery("/metastatement/subproofAssertion!"),
|
|
14
14
|
subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement!/statement!"),
|
|
@@ -20,26 +20,36 @@ const subproofAssertionNodeQuery = nodeQuery("/metastatement/subproofAssertion!"
|
|
|
20
20
|
metaSubproofLastMetaProofStepMetastatementNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation/lastMetaProofStep/unqualifiedMetastatement|qualifiedMetastatement/metastatement!");
|
|
21
21
|
|
|
22
22
|
export default class Premise {
|
|
23
|
-
constructor(metastatementNode) {
|
|
23
|
+
constructor(metastatementNode, statementNode) {
|
|
24
24
|
this.metastatementNode = metastatementNode;
|
|
25
|
+
this.statementnode = statementNode;
|
|
25
26
|
}
|
|
26
27
|
|
|
27
28
|
getMetastatementNode() {
|
|
28
29
|
return this.metastatementNode;
|
|
29
30
|
}
|
|
30
31
|
|
|
32
|
+
getStatementNode() {
|
|
33
|
+
return this.statementnode;
|
|
34
|
+
}
|
|
35
|
+
|
|
31
36
|
matchStatementNode(statementNode, substitutions, fileContext, localContext) {
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
37
|
+
let statementNodeMatches = false;
|
|
38
|
+
|
|
39
|
+
if (this.metastatementNode !== null) {
|
|
40
|
+
const nonTerminalNodeA = this.metastatementNode, ///
|
|
41
|
+
nonTerminalNodeB = statementNode, ///
|
|
42
|
+
fileContextA = fileContext, ///
|
|
43
|
+
localContextA = LocalContext.fromFileContext(fileContextA),
|
|
44
|
+
localContextB = localContext, ///
|
|
45
|
+
nonTerminalNodeVerified = intrinsicLevelAgainstMetaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
|
|
46
|
+
const verifiedAhead = true;
|
|
47
|
+
|
|
48
|
+
return verifiedAhead;
|
|
49
|
+
});
|
|
50
|
+
|
|
51
|
+
statementNodeMatches = nonTerminalNodeVerified; ///
|
|
52
|
+
}
|
|
43
53
|
|
|
44
54
|
return statementNodeMatches;
|
|
45
55
|
}
|
|
@@ -47,33 +57,35 @@ export default class Premise {
|
|
|
47
57
|
matchSubproofNode(subproofNode, substitutions, fileContext, localContext) {
|
|
48
58
|
let subproofNodeMatches = false;
|
|
49
59
|
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
60
|
+
if (this.metastatementNode !== null) {
|
|
61
|
+
const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
|
|
62
|
+
|
|
63
|
+
if (subproofAssertionNode !== null) {
|
|
64
|
+
const subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
|
|
65
|
+
subproofLastProofStepStatementNode = subproofLastProofStepStatementNodeQuery(subproofNode),
|
|
66
|
+
subproofStatementNodes = [
|
|
67
|
+
...subproofSuppositionStatementNodes,
|
|
68
|
+
subproofLastProofStepStatementNode
|
|
69
|
+
],
|
|
70
|
+
subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
|
|
71
|
+
|
|
72
|
+
subproofNodeMatches = match(subproofAssertionMetastatementNodes, subproofStatementNodes, (subproofAssertionMetastatementNode, subproofStatementNode) => {
|
|
73
|
+
const nonTerminalNodeA = subproofAssertionMetastatementNode, ///
|
|
74
|
+
nonTerminalNodeB = subproofStatementNode, ///
|
|
75
|
+
fileContextA = fileContext, ///
|
|
76
|
+
localContextA = LocalMetaContext.fromFileContext(fileContextA),
|
|
77
|
+
localContextB = localContext, ///
|
|
78
|
+
nonTerminalNodeVerified = intrinsicLevelAgainstMetaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
|
|
79
|
+
const verifiedAhead = true;
|
|
80
|
+
|
|
81
|
+
return verifiedAhead;
|
|
82
|
+
});
|
|
83
|
+
|
|
84
|
+
if (nonTerminalNodeVerified) {
|
|
85
|
+
return true;
|
|
86
|
+
}
|
|
87
|
+
});
|
|
88
|
+
}
|
|
77
89
|
}
|
|
78
90
|
|
|
79
91
|
return subproofNodeMatches;
|
|
@@ -82,33 +94,35 @@ export default class Premise {
|
|
|
82
94
|
matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, localMetaContext) {
|
|
83
95
|
let ruleSubproofNodeMatches = false;
|
|
84
96
|
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
97
|
+
if (this.metastatementNode !== null) {
|
|
98
|
+
const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
|
|
99
|
+
|
|
100
|
+
if (subproofAssertionNode !== null) {
|
|
101
|
+
const ruleSubproofPremiseMetastatementNodes = ruleSubproofPremiseMetastatementNodesQuery(ruleSubproofNode),
|
|
102
|
+
ruleSubproofLastRuleProofStepMetastatementNode = ruleSubproofLastRuleProofStepMetastatementNodeQuery(ruleSubproofNode),
|
|
103
|
+
ruleSubproofMetastatementNodes = [
|
|
104
|
+
...ruleSubproofPremiseMetastatementNodes,
|
|
105
|
+
ruleSubproofLastRuleProofStepMetastatementNode
|
|
106
|
+
],
|
|
107
|
+
subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
|
|
108
|
+
|
|
109
|
+
ruleSubproofNodeMatches = match(subproofAssertionMetastatementNodes, ruleSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
|
|
110
|
+
const nonTerminalNodeA = subproofAssertionMetastatementNode, ///
|
|
111
|
+
nonTerminalNodeB = ruleSubproofMetastatementNode, ///
|
|
112
|
+
fileContextA = fileContext, ///
|
|
113
|
+
localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
|
|
114
|
+
localMetaContextB = localMetaContext, ///
|
|
115
|
+
nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
|
|
116
|
+
const verifiedAhead = true;
|
|
117
|
+
|
|
118
|
+
return verifiedAhead;
|
|
119
|
+
});
|
|
120
|
+
|
|
121
|
+
if (nonTerminalNodeVerified) {
|
|
122
|
+
return true;
|
|
123
|
+
}
|
|
124
|
+
});
|
|
125
|
+
}
|
|
112
126
|
}
|
|
113
127
|
|
|
114
128
|
return ruleSubproofNodeMatches;
|
|
@@ -117,77 +131,97 @@ export default class Premise {
|
|
|
117
131
|
matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext) {
|
|
118
132
|
let metaSubproofNodeMatches = false;
|
|
119
133
|
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
134
|
+
if (this.metastatementNode !== null) {
|
|
135
|
+
const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
|
|
136
|
+
|
|
137
|
+
if (subproofAssertionNode !== null) {
|
|
138
|
+
const metaSubproofMetaSuppositionMetastatementNodes = metaSubproofMetaSuppositionMetastatementNodesQuery(metaSubproofNode),
|
|
139
|
+
metaSubproofLastMetaProofStepMetastatementNode = metaSubproofLastMetaProofStepMetastatementNodeQuery(metaSubproofNode),
|
|
140
|
+
metaSubproofMetastatementNodes = [
|
|
141
|
+
...metaSubproofMetaSuppositionMetastatementNodes,
|
|
142
|
+
metaSubproofLastMetaProofStepMetastatementNode
|
|
143
|
+
],
|
|
144
|
+
subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
|
|
145
|
+
|
|
146
|
+
metaSubproofNodeMatches = match(subproofAssertionMetastatementNodes, metaSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
|
|
147
|
+
const nonTerminalNodeA = subproofAssertionMetastatementNode, ///
|
|
148
|
+
nonTerminalNodeB = ruleSubproofMetastatementNode, ///
|
|
149
|
+
fileContextA = fileContext, ///
|
|
150
|
+
localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
|
|
151
|
+
localMetaContextB = localMetaContext, ///
|
|
152
|
+
nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
|
|
153
|
+
const verifiedAhead = true;
|
|
154
|
+
|
|
155
|
+
return verifiedAhead;
|
|
156
|
+
});
|
|
157
|
+
|
|
158
|
+
if (nonTerminalNodeVerified) {
|
|
159
|
+
return true;
|
|
160
|
+
}
|
|
161
|
+
});
|
|
162
|
+
}
|
|
147
163
|
}
|
|
148
164
|
|
|
149
165
|
return metaSubproofNodeMatches;
|
|
150
166
|
}
|
|
151
167
|
|
|
152
168
|
matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext) {
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
169
|
+
let metastatementNodeMatches = false;
|
|
170
|
+
|
|
171
|
+
if (this.metastatementNode !== null) {
|
|
172
|
+
const nonTerminalNodeA = this.metastatementNode, ///
|
|
173
|
+
nonTerminalNodeB = metastatementNode, ///
|
|
174
|
+
fileContextA = fileContext, ///
|
|
175
|
+
localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
|
|
176
|
+
localMetaContextB = localMetaContext, ///
|
|
177
|
+
nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
|
|
178
|
+
const verifiedAhead = true;
|
|
179
|
+
|
|
180
|
+
return verifiedAhead;
|
|
181
|
+
});
|
|
182
|
+
|
|
183
|
+
metastatementNodeMatches = nonTerminalNodeVerified; ///
|
|
184
|
+
}
|
|
164
185
|
|
|
165
186
|
return metastatementNodeMatches;
|
|
166
187
|
}
|
|
167
188
|
|
|
168
189
|
toJSON(tokens) {
|
|
169
190
|
const metastatementString = nodeAsString(this.metastatementNode, tokens),
|
|
191
|
+
statementString = nodeAsString(this.statementnode, tokens),
|
|
170
192
|
metastatement = metastatementString, ///
|
|
193
|
+
statement = statementString, ///
|
|
171
194
|
json = {
|
|
172
|
-
metastatement
|
|
195
|
+
metastatement,
|
|
196
|
+
statement
|
|
173
197
|
};
|
|
174
198
|
|
|
175
199
|
return json;
|
|
176
200
|
}
|
|
177
201
|
|
|
178
202
|
static fromJSONAndFileContext(json, fileContext) {
|
|
179
|
-
const { metastatement } = json,
|
|
203
|
+
const { metastatement, statement } = json,
|
|
180
204
|
metastatementString = metastatement, ///
|
|
205
|
+
statementString = statement, ///
|
|
181
206
|
lexer = fileContext.getLexer(),
|
|
182
207
|
parser = fileContext.getParser(),
|
|
183
208
|
metastatementNode = metastatementNodeFromMetastatementString(metastatementString, lexer, parser),
|
|
184
|
-
|
|
209
|
+
statementNode = statementNodeFromStatementString(statementString, lexer, parser),
|
|
210
|
+
premise = new Premise(metastatementNode, statementNode);
|
|
185
211
|
|
|
186
212
|
return premise;
|
|
187
213
|
}
|
|
188
214
|
|
|
189
215
|
static fromMetastatementNode(metastatementNode) {
|
|
190
|
-
const
|
|
216
|
+
const statementNode = null,
|
|
217
|
+
premise = new Premise(metastatementNode, statementNode);
|
|
218
|
+
|
|
219
|
+
return premise;
|
|
220
|
+
}
|
|
221
|
+
|
|
222
|
+
static fromStatementNode(statementNode) {
|
|
223
|
+
const metastatementNode = null,
|
|
224
|
+
premise = new Premise(metastatementNode, statementNode);
|
|
191
225
|
|
|
192
226
|
return premise;
|
|
193
227
|
}
|
|
@@ -13,7 +13,6 @@ const termNodeQuery = nodeQuery("/term!"),
|
|
|
13
13
|
termVariableNodeQuery = nodeQuery("/term/variable!"),
|
|
14
14
|
metastatementNodeQuery = nodeQuery("/metastatement!"),
|
|
15
15
|
metaArgumentStatementNodeQuery = nodeQuery("/metaArgument/statement!"),
|
|
16
|
-
metastatementStatementNodeQuery = nodeQuery("/metastatement/statement!"),
|
|
17
16
|
metastatementMetavariableNodeQuery = nodeQuery("/metastatement/metavariable!"),
|
|
18
17
|
metastatementSubstitutionNodeQuery = nodeQuery("/metastatement/substitution");
|
|
19
18
|
|
|
@@ -22,24 +21,6 @@ class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
|
|
|
22
21
|
let nonTerminalNodeVerified;
|
|
23
22
|
|
|
24
23
|
const nodeQueryMaps = [
|
|
25
|
-
{
|
|
26
|
-
nodeQueryA: metastatementMetavariableNodeQuery,
|
|
27
|
-
nodeQueryB: metastatementStatementNodeQuery,
|
|
28
|
-
verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
|
|
29
|
-
let nonTerminalNodeVerified;
|
|
30
|
-
|
|
31
|
-
const metastatementStatementNodeB = nodeB, ///
|
|
32
|
-
metastatementMetavariableNodeA = nodeA, ///
|
|
33
|
-
metastatementSubstitutionNodeA = metastatementSubstitutionNodeQuery(nonTerminalNodeA),
|
|
34
|
-
metastatementMetavariableNodeVerifiedAgainstMetastatementStatementNode =
|
|
35
|
-
|
|
36
|
-
this.verifyMetastatementMetavariableNodeAgainstMetastatementStatementNode(metastatementMetavariableNodeA, metastatementStatementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead);
|
|
37
|
-
|
|
38
|
-
nonTerminalNodeVerified = metastatementMetavariableNodeVerifiedAgainstMetastatementStatementNode; ///
|
|
39
|
-
|
|
40
|
-
return nonTerminalNodeVerified;
|
|
41
|
-
}
|
|
42
|
-
},
|
|
43
24
|
{
|
|
44
25
|
nodeQueryA: metastatementMetavariableNodeQuery,
|
|
45
26
|
nodeQueryB: metaArgumentStatementNodeQuery,
|
|
@@ -76,23 +57,6 @@ class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
|
|
|
76
57
|
return nonTerminalNodeVerified;
|
|
77
58
|
}
|
|
78
59
|
},
|
|
79
|
-
{
|
|
80
|
-
nodeQueryA: metastatementStatementNodeQuery,
|
|
81
|
-
nodeQueryB: statementNodeQuery,
|
|
82
|
-
verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
|
|
83
|
-
let nonTerminalNodeVerified;
|
|
84
|
-
|
|
85
|
-
const statementNodeB = nodeB, ///
|
|
86
|
-
metastatementStatementNodeA = nodeA, ///
|
|
87
|
-
metastatementStatementNodeVerifiedAgainstStatementNode =
|
|
88
|
-
|
|
89
|
-
this.verifyMetastatementStatementNodeAgainstStatementNode(metastatementStatementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead);
|
|
90
|
-
|
|
91
|
-
nonTerminalNodeVerified = metastatementStatementNodeVerifiedAgainstStatementNode; ///
|
|
92
|
-
|
|
93
|
-
return nonTerminalNodeVerified;
|
|
94
|
-
}
|
|
95
|
-
},
|
|
96
60
|
{
|
|
97
61
|
nodeQueryA: metastatementNodeQuery,
|
|
98
62
|
nodeQueryB: statementNodeQuery,
|
|
@@ -138,19 +102,6 @@ class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
|
|
|
138
102
|
return nonTerminalNodeVerified;
|
|
139
103
|
}
|
|
140
104
|
|
|
141
|
-
verifyMetastatementMetavariableNodeAgainstMetastatementStatementNode(metastatementMetavariableNodeA, metastatementStatementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead) {
|
|
142
|
-
let metastatementMetavariableNodeVerifiedAgainstMetastatementStatementNode;
|
|
143
|
-
|
|
144
|
-
const statementNode = metastatementStatementNodeB, ///
|
|
145
|
-
metavariableNode = metastatementMetavariableNodeA, ///
|
|
146
|
-
substitutionNode = metastatementSubstitutionNodeA, ///
|
|
147
|
-
metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNode, statementNode, substitutionNode, substitutions, localContextA, localContextB, verifyAhead)
|
|
148
|
-
|
|
149
|
-
metastatementMetavariableNodeVerifiedAgainstMetastatementStatementNode = metavariableVerifiedAgainstStatement; ///
|
|
150
|
-
|
|
151
|
-
return metastatementMetavariableNodeVerifiedAgainstMetastatementStatementNode;
|
|
152
|
-
}
|
|
153
|
-
|
|
154
105
|
verifyMetastatementMetavariableNodeAgainstMetaArgumentStatementNode(metastatementMetavariableNodeA, metaArgumentStatementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead) {
|
|
155
106
|
let metastatementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode;
|
|
156
107
|
|
|
@@ -177,18 +128,6 @@ class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
|
|
|
177
128
|
return metastatementMetavariableNodeVerifiedAgainstStatementNode;
|
|
178
129
|
}
|
|
179
130
|
|
|
180
|
-
verifyMetastatementStatementNodeAgainstStatementNode(metastatementStatementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead) {
|
|
181
|
-
let metastatementStatementNodeVerifiedAgainstStatementNode;
|
|
182
|
-
|
|
183
|
-
const nonTerminalNodeA = metastatementStatementNodeA, ///
|
|
184
|
-
nonTerminalNodeB = statementNodeB, ///
|
|
185
|
-
nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
|
|
186
|
-
|
|
187
|
-
metastatementStatementNodeVerifiedAgainstStatementNode = nonTerminalNodeVerified; ///
|
|
188
|
-
|
|
189
|
-
return metastatementStatementNodeVerifiedAgainstStatementNode;
|
|
190
|
-
}
|
|
191
|
-
|
|
192
131
|
verifyMetastatementNodeAgainstStatementNode(metastatementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead) {
|
|
193
132
|
let metastatementNodeVerifiedAgainstStatementNode;
|
|
194
133
|
|