occam-verify-cli 0.0.902 → 0.0.904

package/src/verifier/node/metastatement.js

@@ -11,6 +11,7 @@ import { verifyStandaloneMetavariable } from "../../verify/metavariable";
 
 const termNodeQuery = nodeQuery("/term!"),
       variableNodeQuery = nodeQuery("/variable!"),
+      nonTerminalNodeQuery = nodeQuery("/*"),
       metavariableNodeQuery = nodeQuery("/metavariable!");
 
 class MetastatementNodeVerifier extends NodeVerifier {
@@ -20,23 +21,62 @@ class MetastatementNodeVerifier extends NodeVerifier {
     const nodeQueryMaps = [
       {
         nodeQuery: termNodeQuery,
-        verifyNode: this.verifyTermNode
+        verifyNode: (node, localMetaContext, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const termNode = node, ///
+                termNodeVerified = this.verifyTermNode(termNode, localMetaContext, verifyAhead);
+
+          nonTerminalNodeVerified = termNodeVerified; ///
+
+          return nonTerminalNodeVerified;
+        }
       },
       {
         nodeQuery: variableNodeQuery,
-        verifyNode: this.verifyVariableNode
+        verifyNode: (node, localMetaContext, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const variableNode = node, ///
+                variableNodeVerified = this.verifyVariableNode(variableNode, localMetaContext, verifyAhead);
+
+          nonTerminalNodeVerified = variableNodeVerified; ///
+
+          return nonTerminalNodeVerified;
+        }
       },
       {
         nodeQuery: metavariableNodeQuery,
-        verifyNode: this.verifyMetavariableNode
+        verifyNode: (node, localMetaContext, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const metavariableNode = node, ///
+                metavariableNodeVerified = this.verifyMetavariableNode(metavariableNode, localMetaContext, verifyAhead);
+
+          nonTerminalNodeVerified = metavariableNodeVerified; ///
+
+          return nonTerminalNodeVerified;
+        }
+      },
+      {
+        nodeQuery: nonTerminalNodeQuery,
+        verifyNode: (node, localMetaContext, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const nonTerminalNode = node; ///
+
+          nonTerminalNodeVerified =
+
+            super.verifyNonTerminalNode(nonTerminalNode, localMetaContext, verifyAhead);
+
+          return nonTerminalNodeVerified;
+        }
       }
     ];
 
     const nodeVerified = verifyNode(nodeQueryMaps, nonTerminalNode, localMetaContext, verifyAhead);
 
-    nonTerminalNodeVerified = nodeVerified ?
-                                true :
-                                  super.verifyNonTerminalNode(nonTerminalNode, localMetaContext, verifyAhead);
+    nonTerminalNodeVerified = nodeVerified; ///
 
     return nonTerminalNodeVerified;
   }

package/src/verifier/node/statementAsCombinator.js

@@ -10,7 +10,8 @@ import { verifyStandaloneStatement } from "../../verify/statement";
 
 const termNodeQuery = nodeQuery("/term!"),
       typeNodeQuery = nodeQuery("/type!"),
-      statementNodeQuery = nodeQuery("/statement!");
+      statementNodeQuery = nodeQuery("/statement!"),
+      nonTerminalNodeQuery = nodeQuery("/*");
 
 class StatementAsCombinatorNodeVerifier extends NodeVerifier {
   verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
@@ -19,44 +20,83 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
     const nodeQueryMaps = [
       {
         nodeQuery: termNodeQuery,
-        verifyNode: this.verifyTermNode
+        verifyNode: (node, localMetaContext, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const termNode = node, ///
+                termNodeVerified = this.verifyTermNode(termNode, localMetaContext, verifyAhead);
+
+          nonTerminalNodeVerified = termNodeVerified; ///
+
+          return nonTerminalNodeVerified;
+        }
       },
       {
         nodeQuery: typeNodeQuery,
-        verifyNode: this.verifyTypeNode
+        verifyNode: (node, localMetaContext, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const typeNode = node, ///
+                typeNodeVerified = this.verifyTypeNode(typeNode, localMetaContext, verifyAhead);
+
+          nonTerminalNodeVerified = typeNodeVerified; ///
+
+          return nonTerminalNodeVerified;
+        }
       },
       {
         nodeQuery: statementNodeQuery,
-        verifyNode: this.verifyStatementNode
+        verifyNode: (node, localMetaContext, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const statementNode = node, ///
+                statementNodeVerified = this.verifyStatementNode(statementNode, localMetaContext, verifyAhead);
+
+          nonTerminalNodeVerified = statementNodeVerified; ///
+
+          return nonTerminalNodeVerified;
+        }
+      },
+      {
+        nodeQuery: nonTerminalNodeQuery,
+        verifyNode: (node, localMetaContext, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const nonTerminalNode = node; ///
+
+          nonTerminalNodeVerified =
+
+            super.verifyNonTerminalNode(nonTerminalNode, localMetaContext, verifyAhead);
+
+          return nonTerminalNodeVerified;
+        }
       }
     ];
 
     const nodeVerified = verifyNode(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
 
-    nonTerminalNodeVerified = nodeVerified ?
-                                true :
-                                  super.verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead);
+    nonTerminalNodeVerified = nodeVerified; ///
 
     return nonTerminalNodeVerified;
   }
 
   verifyStatementNode(statementNode, localContext, verifyAhead) {
     const standaloneStatementVerified = verifyStandaloneStatement(statementNode, localContext, verifyAhead),
-          statementNodeVerified = standaloneStatementVerified; ///
+          statementNodeVerified = standaloneStatementVerified;  ///
 
     return statementNodeVerified;
   }
 
   verifyTermNode(termNode, localContext, verifyAhead) {
     const standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
-      termNodeVerified = standaloneTermVerified;  ///
+          termNodeVerified = standaloneTermVerified;  ///
 
     return termNodeVerified;
   }
 
   verifyTypeNode(typeNode, localContext, verifyAhead) {
     const standaloneTypeVerified = verifyStandaloneType(typeNode, localContext, verifyAhead),
-      typeNodeVerified = standaloneTypeVerified;  ///
+          typeNodeVerified = standaloneTypeVerified;  ///
 
     return typeNodeVerified;
   }

package/src/verifier/node/termAsConstructor.js

@@ -8,7 +8,8 @@ import { verifyStandaloneType } from "../../verify/type";
 import { verifyStandaloneTerm } from "../../verify/term";
 
 const termNodeQuery = nodeQuery("/term!"),
-      typeNodeQuery = nodeQuery("/type!");
+      typeNodeQuery = nodeQuery("/type!"),
+      nonTerminalNodeQuery = nodeQuery("/*");
 
 class TermAsConstructorNodeVerifier extends NodeVerifier {
   verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
@@ -17,19 +18,49 @@ class TermAsConstructorNodeVerifier extends NodeVerifier {
     const nodeQueryMaps = [
       {
         nodeQuery: termNodeQuery,
-        verifyNode: this.verifyTermNode
+        verifyNode: (node, localMetaContext, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const termNode = node, ///
+            termNodeVerified = this.verifyTermNode(termNode, localMetaContext, verifyAhead);
+
+          nonTerminalNodeVerified = termNodeVerified; ///
+
+          return nonTerminalNodeVerified;
+        }
       },
       {
         nodeQuery: typeNodeQuery,
-        verifyNode: this.verifyTypeNode
+        verifyNode: (node, localMetaContext, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const typeNode = node, ///
+            typeNodeVerified = this.verifyTypeNode(typeNode, localMetaContext, verifyAhead);
+
+          nonTerminalNodeVerified = typeNodeVerified; ///
+
+          return nonTerminalNodeVerified;
+        }
+      },
+      {
+        nodeQuery: nonTerminalNodeQuery,
+        verifyNode: (node, localMetaContext, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const nonTerminalNode = node; ///
+
+          nonTerminalNodeVerified =
+
+            super.verifyNonTerminalNode(nonTerminalNode, localMetaContext, verifyAhead);
+
+          return nonTerminalNodeVerified;
+        }
       }
     ];
 
     const nodeVerified = verifyNode(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
 
-    nonTerminalNodeVerified = nodeVerified ?
-                                true :
-                                  super.verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead);
+    nonTerminalNodeVerified = nodeVerified; ///
 
     return nonTerminalNodeVerified;
   }

package/src/verifier/nodes/equality.js

@@ -6,7 +6,8 @@ import verifyTermAgainstTerm from "../../verify/termAgainstTerm";
 import { nodeQuery } from "../../utilities/query";
 import { verifyNodes } from "../../utilities/verifier";
 
-const termNodeQuery = nodeQuery("/term!");
+const termNodeQuery = nodeQuery("/term!"),
+      nonTerminalNodeQuery = nodeQuery("/*");
 
 class EqualityNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead) {
@@ -27,6 +28,22 @@ class EqualityNodesVerifier extends NodesVerifier {
 
           nonTerminalNodeVerified = termNodeVerifiedAgainstTermNode; ///
 
+          return nonTerminalNodeVerified;
+        }
+      },
+      {
+        nodeQueryA: nonTerminalNodeQuery,
+        nodeQueryB: nonTerminalNodeQuery,
+        verifyNodes: (nodeA, nodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const nonTerminalNodeA = nodeA, ///
+                nonTerminalNodeB = nodeB; ///
+
+          nonTerminalNodeVerified =
+
+            super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
+
           return nonTerminalNodeVerified;
         }
       }
@@ -34,9 +51,7 @@ class EqualityNodesVerifier extends NodesVerifier {
 
     const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
 
-    nonTerminalNodeVerified = nodesVerified ?
-                                 true :
-                                   super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
+    nonTerminalNodeVerified = nodesVerified;  ///
 
     return nonTerminalNodeVerified;
   }

package/src/verifier/nodes/intrinsicLevel.js

@@ -7,6 +7,7 @@ import { nodeQuery } from "../../utilities/query";
 import { verifyNodes } from "../../utilities/verifier";
 
 const termNodeQuery = nodeQuery("/term!"),
+      nonTerminalNodeQuery = nodeQuery("/*"),
       termVariableNodeQuery = nodeQuery("/term/variable!");
 
 class IntrinsicLevelNodesVerifier extends NodesVerifier {
@@ -28,6 +29,22 @@ class IntrinsicLevelNodesVerifier extends NodesVerifier {
 
           nonTerminalNodeVerified = termVariableNodeVerifiedAgainstTermNode;  ///
 
+          return nonTerminalNodeVerified;
+        }
+      },
+      {
+        nodeQueryA: nonTerminalNodeQuery,
+        nodeQueryB: nonTerminalNodeQuery,
+        verifyNodes: (nodeA, nodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const nonTerminalNodeA = nodeA, ///
+                nonTerminalNodeB = nodeB; ///
+
+          nonTerminalNodeVerified =
+
+            super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
+
           return nonTerminalNodeVerified;
         }
       }
@@ -35,9 +52,7 @@ class IntrinsicLevelNodesVerifier extends NodesVerifier {
 
     const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
-    nonTerminalNodeVerified = nodesVerified ?
-                                true :
-                                  super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
+    nonTerminalNodeVerified = nodesVerified;  ///
 
     return nonTerminalNodeVerified;
   }

package/src/verifier/nodes/intrinsicLevelAgainstMetaLevel.js

@@ -10,6 +10,7 @@ import { verifyNodes } from "../../utilities/verifier";
 
 const termNodeQuery = nodeQuery("/term!"),
       statementNodeQuery = nodeQuery("/statement!"),
+      nonTerminalNodeQuery = nodeQuery("/*"),
       termVariableNodeQuery = nodeQuery("/term/variable!"),
       metastatementNodeQuery = nodeQuery("/metastatement!"),
       metaArgumentStatementNodeQuery = nodeQuery("/metaArgument/statement!"),
@@ -88,6 +89,22 @@ class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
 
           nonTerminalNodeVerified = termVariableNodeVerifiedAgainstTermNode;  ///
 
+          return nonTerminalNodeVerified;
+        }
+      },
+      {
+        nodeQueryA: nonTerminalNodeQuery,
+        nodeQueryB: nonTerminalNodeQuery,
+        verifyNodes: (nodeA, nodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const nonTerminalNodeA = nodeA, ///
+                nonTerminalNodeB = nodeB; ///
+
+          nonTerminalNodeVerified =
+
+            super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
+
           return nonTerminalNodeVerified;
         }
       }
@@ -95,9 +112,7 @@ class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
 
     const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
-    nonTerminalNodeVerified = nodesVerified ?
-                                true :
-                                  super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
+    nonTerminalNodeVerified = nodesVerified;  ///
 
     return nonTerminalNodeVerified;
   }

package/src/verifier/nodes/metaLevel.js

@@ -6,7 +6,8 @@ import verifyMetavariableAgainstMetastatement from "../../verify/metavariableAga
 import { nodeQuery } from "../../utilities/query";
 import { verifyNodes } from "../../utilities/verifier";
 
-const metastatementNodeQuery = nodeQuery("/metastatement!"),
+const nonTerminalNodeQuery = nodeQuery("/*"),
+      metastatementNodeQuery = nodeQuery("/metastatement!"),
       metastatementMetavariableNodeQuery = nodeQuery("/metastatement/metavariable!");
 
 class MetaLevelNodesVerifier extends NodesVerifier {
@@ -28,6 +29,22 @@ class MetaLevelNodesVerifier extends NodesVerifier {
 
           nonTerminalNodeVerified = metastatementMetavariableNodeVerifiedAgainstMetastatementNode;  ///
 
+          return nonTerminalNodeVerified;
+        }
+      },
+      {
+        nodeQueryA: nonTerminalNodeQuery,
+        nodeQueryB: nonTerminalNodeQuery,
+        verifyNodes: (nodeA, nodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const nonTerminalNodeA = nodeA, ///
+                nonTerminalNodeB = nodeB; ///
+
+          nonTerminalNodeVerified =
+
+            super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
+
           return nonTerminalNodeVerified;
         }
       }
@@ -35,9 +52,7 @@ class MetaLevelNodesVerifier extends NodesVerifier {
 
     const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
 
-    nonTerminalNodeVerified = nodesVerified ?
-                                true :
-                                  super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
+    nonTerminalNodeVerified = nodesVerified;  ///
 
     return nonTerminalNodeVerified;
   }

package/src/verifier/nodes/statementAgainstCombinator.js

@@ -8,6 +8,7 @@ import { nodeQuery } from "../../utilities/query";
 import { verifyNodes } from "../../utilities/verifier";
 
 const argumentNodeQuery = nodeQuery("/argument!"),
+      nonTerminalNodeQuery = nodeQuery("/*"),
       metaArgumentMetaTypeNodeQuery = nodeQuery("/metaArgument/metaType!"),
       metaArgumentStatementNodeQuery = nodeQuery("/metaArgument/statement!");
 
@@ -47,6 +48,22 @@ class StatementAgainstCombinatorNodesVerifier extends NodesVerifier {
 
           nonTerminalNodeVerified = argumentNodeVerifiedAgainstArgumentNode; ///
 
+          return nonTerminalNodeVerified;
+        }
+      },
+      {
+        nodeQueryA: nonTerminalNodeQuery,
+        nodeQueryB: nonTerminalNodeQuery,
+        verifyNodes: (nodeA, nodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const nonTerminalNodeA = nodeA, ///
+               nonTerminalNodeB = nodeB; ///
+
+          nonTerminalNodeVerified =
+
+            super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
+
           return nonTerminalNodeVerified;
         }
       }
@@ -54,9 +71,7 @@ class StatementAgainstCombinatorNodesVerifier extends NodesVerifier {
 
     const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
 
-    nonTerminalNodeVerified = nodesVerified ?
-                                true :
-                                  super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
+    nonTerminalNodeVerified = nodesVerified;  ///
 
     return nonTerminalNodeVerified;
   }

package/src/verifier/nodes/termAgainstConstructor.js

@@ -7,7 +7,8 @@ import { nodeQuery } from "../../utilities/query";
 import { verifyNodes } from "../../utilities/verifier";
 
 const termNodeQuery = nodeQuery("/argument/term!"),
-      typeNodeQuery = nodeQuery("/argument/type!");
+      typeNodeQuery = nodeQuery("/argument/type!"),
+      nonTerminalNodeQuery = nodeQuery("/*");
 
 class TermAgainstConstructorNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead) {
@@ -28,6 +29,22 @@ class TermAgainstConstructorNodesVerifier extends NodesVerifier {
 
           nonTerminalNodeVerified = termNodeVerifiedAgainstTypeNode;  ///
 
+          return nonTerminalNodeVerified;
+        }
+      },
+      {
+        nodeQueryA: nonTerminalNodeQuery,
+        nodeQueryB: nonTerminalNodeQuery,
+        verifyNodes: (nodeA, nodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const nonTerminalNodeA = nodeA, ///
+                nonTerminalNodeB = nodeB; ///
+
+          nonTerminalNodeVerified =
+
+            super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
+
           return nonTerminalNodeVerified;
         }
       }
@@ -35,9 +52,7 @@ class TermAgainstConstructorNodesVerifier extends NodesVerifier {
 
     const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
 
-    nonTerminalNodeVerified = nodesVerified ?
-                                true :
-                                  super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
+    nonTerminalNodeVerified = nodesVerified;  ///
 
     return nonTerminalNodeVerified;
   }

package/src/verify/containedAssertion.js

@@ -4,7 +4,7 @@ import { isAssertionNegated } from "../utilities/verify";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const variableNodeQuery = nodeQuery("/containedAssertion/term/variable!"),
-      metastatementVariableNodesQuery = nodesQuery("/containedAssertion/metastatement//variable");
+      metastatementVariableNodesQuery = nodesQuery("/containedAssertion/statement//variable");
 
 export default function verifyContainedAssertion(containedAssertionNode) {
   let containedAssertionVerified = false;

package/src/verify/premise.js

@@ -29,8 +29,6 @@ export default function verifyPremise(premiseNode, premises, localMetaContext) {
 
       premiseVerified = assignmentAssigned; ///
     }
-  } else {
-    debugger
   }
 
   if (premiseVerified) {

package/src/verify/statement/qualified.js

@@ -33,11 +33,7 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
   if (qualifiedStatementVerified) {
     const derived = false,
           statementNode = statementNodeQuery(qualifiedStatementNode),
-          statementVerified = verifyStatement(statementNode, assignments, derived, localContext, () => {
-            const verifiedAhead = true;
-
-            return verifiedAhead;
-          });
+          statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
     qualifiedStatementVerified = statementVerified;  ///
   }
@@ -169,7 +165,7 @@ function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, meta
   return qualifiedStatementVerifiedAgainstConjecture;
 }
 
-function verifyStatement(statementNode, assignments, derived, localContext, verifyAhead) {
+function verifyStatement(statementNode, assignments, derived, localContext) {
   let statementVerified;
 
   const statementString = localContext.nodeAsString(statementNode);
@@ -182,7 +178,7 @@ function verifyStatement(statementNode, assignments, derived, localContext, veri
   ];
 
   verifyStatementFunctions.some((verifyStatementFunction) => {
-    const statementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext, verifyAhead);
+    const statementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext);
 
     if (statementVerified) {
       return true;

package/src/verify/statement/unqualified.js

@@ -21,11 +21,7 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, ass
   }
 
   if (!unqualifiedStatementVerified) {
-    const statementVerified = verifyStatement(statementNode, assignments, derived, localContext, () => {
-            const verifiedAhead = true;
-
-            return verifiedAhead;
-          });
+    const statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
     unqualifiedStatementVerified = statementVerified;  ///
   }